1 /* Generic partial redundancy elimination with lazy code motion support.
2 Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005
3 Free Software Foundation, Inc.
5 This file is part of GCC.
7 GCC is free software; you can redistribute it and/or modify it under
8 the terms of the GNU General Public License as published by the Free
9 Software Foundation; either version 2, or (at your option) any later
12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
14 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING. If not, write to the Free
19 Software Foundation, 59 Temple Place - Suite 330, Boston, MA
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. */
55 #include "coretypes.h"
59 #include "hard-reg-set.h"
62 #include "insn-config.h"
64 #include "basic-block.h"
69 /* We want target macros for the mode switching code to be able to refer
70 to instruction attribute values. */
71 #include "insn-attr.h"
73 /* Edge based LCM routines. */
74 static void compute_antinout_edge (sbitmap
*, sbitmap
*, sbitmap
*, sbitmap
*);
75 static void compute_earliest (struct edge_list
*, int, sbitmap
*, sbitmap
*,
76 sbitmap
*, sbitmap
*, sbitmap
*);
77 static void compute_laterin (struct edge_list
*, sbitmap
*, sbitmap
*,
78 sbitmap
*, sbitmap
*);
79 static void compute_insert_delete (struct edge_list
*edge_list
, sbitmap
*,
80 sbitmap
*, sbitmap
*, sbitmap
*, sbitmap
*);
82 /* Edge based LCM routines on a reverse flowgraph. */
83 static void compute_farthest (struct edge_list
*, int, sbitmap
*, sbitmap
*,
84 sbitmap
*, sbitmap
*, sbitmap
*);
85 static void compute_nearerout (struct edge_list
*, sbitmap
*, sbitmap
*,
86 sbitmap
*, sbitmap
*);
87 static void compute_rev_insert_delete (struct edge_list
*edge_list
, sbitmap
*,
88 sbitmap
*, sbitmap
*, sbitmap
*,
91 /* Edge based lcm routines. */
93 /* Compute expression anticipatability at entrance and exit of each block.
94 This is done based on the flow graph, and not on the pred-succ lists.
95 Other than that, its pretty much identical to compute_antinout. */
98 compute_antinout_edge (sbitmap
*antloc
, sbitmap
*transp
, sbitmap
*antin
,
103 basic_block
*worklist
, *qin
, *qout
, *qend
;
107 /* Allocate a worklist array/queue. Entries are only added to the
108 list if they were not already on the list. So the size is
109 bounded by the number of basic blocks. */
110 qin
= qout
= worklist
= xmalloc (sizeof (basic_block
) * n_basic_blocks
);
112 /* We want a maximal solution, so make an optimistic initialization of
114 sbitmap_vector_ones (antin
, last_basic_block
);
116 /* Put every block on the worklist; this is necessary because of the
117 optimistic initialization of ANTIN above. */
118 FOR_EACH_BB_REVERSE (bb
)
125 qend
= &worklist
[n_basic_blocks
];
126 qlen
= n_basic_blocks
;
128 /* Mark blocks which are predecessors of the exit block so that we
129 can easily identify them below. */
130 FOR_EACH_EDGE (e
, ei
, EXIT_BLOCK_PTR
->preds
)
131 e
->src
->aux
= EXIT_BLOCK_PTR
;
133 /* Iterate until the worklist is empty. */
136 /* Take the first entry off the worklist. */
143 if (bb
->aux
== EXIT_BLOCK_PTR
)
144 /* Do not clear the aux field for blocks which are predecessors of
145 the EXIT block. That way we never add then to the worklist
147 sbitmap_zero (antout
[bb
->index
]);
150 /* Clear the aux field of this block so that it can be added to
151 the worklist again if necessary. */
153 sbitmap_intersection_of_succs (antout
[bb
->index
], antin
, bb
->index
);
156 if (sbitmap_a_or_b_and_c_cg (antin
[bb
->index
], antloc
[bb
->index
],
157 transp
[bb
->index
], antout
[bb
->index
]))
158 /* If the in state of this block changed, then we need
159 to add the predecessors of this block to the worklist
160 if they are not already on the worklist. */
161 FOR_EACH_EDGE (e
, ei
, bb
->preds
)
162 if (!e
->src
->aux
&& e
->src
!= ENTRY_BLOCK_PTR
)
172 clear_aux_for_edges ();
173 clear_aux_for_blocks ();
177 /* Compute the earliest vector for edge based lcm. */
180 compute_earliest (struct edge_list
*edge_list
, int n_exprs
, sbitmap
*antin
,
181 sbitmap
*antout
, sbitmap
*avout
, sbitmap
*kill
,
184 sbitmap difference
, temp_bitmap
;
186 basic_block pred
, succ
;
188 num_edges
= NUM_EDGES (edge_list
);
190 difference
= sbitmap_alloc (n_exprs
);
191 temp_bitmap
= sbitmap_alloc (n_exprs
);
193 for (x
= 0; x
< num_edges
; x
++)
195 pred
= INDEX_EDGE_PRED_BB (edge_list
, x
);
196 succ
= INDEX_EDGE_SUCC_BB (edge_list
, x
);
197 if (pred
== ENTRY_BLOCK_PTR
)
198 sbitmap_copy (earliest
[x
], antin
[succ
->index
]);
201 if (succ
== EXIT_BLOCK_PTR
)
202 sbitmap_zero (earliest
[x
]);
205 sbitmap_difference (difference
, antin
[succ
->index
],
207 sbitmap_not (temp_bitmap
, antout
[pred
->index
]);
208 sbitmap_a_and_b_or_c (earliest
[x
], difference
,
209 kill
[pred
->index
], temp_bitmap
);
214 sbitmap_free (temp_bitmap
);
215 sbitmap_free (difference
);
218 /* later(p,s) is dependent on the calculation of laterin(p).
219 laterin(p) is dependent on the calculation of later(p2,p).
221 laterin(ENTRY) is defined as all 0's
222 later(ENTRY, succs(ENTRY)) are defined using laterin(ENTRY)
223 laterin(succs(ENTRY)) is defined by later(ENTRY, succs(ENTRY)).
225 If we progress in this manner, starting with all basic blocks
226 in the work list, anytime we change later(bb), we need to add
227 succs(bb) to the worklist if they are not already on the worklist.
231 We prime the worklist all the normal basic blocks. The ENTRY block can
232 never be added to the worklist since it is never the successor of any
233 block. We explicitly prevent the EXIT block from being added to the
236 We optimistically initialize LATER. That is the only time this routine
237 will compute LATER for an edge out of the entry block since the entry
238 block is never on the worklist. Thus, LATERIN is neither used nor
239 computed for the ENTRY block.
241 Since the EXIT block is never added to the worklist, we will neither
242 use nor compute LATERIN for the exit block. Edges which reach the
243 EXIT block are handled in the normal fashion inside the loop. However,
244 the insertion/deletion computation needs LATERIN(EXIT), so we have
248 compute_laterin (struct edge_list
*edge_list
, sbitmap
*earliest
,
249 sbitmap
*antloc
, sbitmap
*later
, sbitmap
*laterin
)
253 basic_block
*worklist
, *qin
, *qout
, *qend
, bb
;
257 num_edges
= NUM_EDGES (edge_list
);
259 /* Allocate a worklist array/queue. Entries are only added to the
260 list if they were not already on the list. So the size is
261 bounded by the number of basic blocks. */
262 qin
= qout
= worklist
263 = xmalloc (sizeof (basic_block
) * (n_basic_blocks
+ 1));
265 /* Initialize a mapping from each edge to its index. */
266 for (i
= 0; i
< num_edges
; i
++)
267 INDEX_EDGE (edge_list
, i
)->aux
= (void *) (size_t) i
;
269 /* We want a maximal solution, so initially consider LATER true for
270 all edges. This allows propagation through a loop since the incoming
271 loop edge will have LATER set, so if all the other incoming edges
272 to the loop are set, then LATERIN will be set for the head of the
275 If the optimistic setting of LATER on that edge was incorrect (for
276 example the expression is ANTLOC in a block within the loop) then
277 this algorithm will detect it when we process the block at the head
278 of the optimistic edge. That will requeue the affected blocks. */
279 sbitmap_vector_ones (later
, num_edges
);
281 /* Note that even though we want an optimistic setting of LATER, we
282 do not want to be overly optimistic. Consider an outgoing edge from
283 the entry block. That edge should always have a LATER value the
284 same as EARLIEST for that edge. */
285 FOR_EACH_EDGE (e
, ei
, ENTRY_BLOCK_PTR
->succs
)
286 sbitmap_copy (later
[(size_t) e
->aux
], earliest
[(size_t) e
->aux
]);
288 /* Add all the blocks to the worklist. This prevents an early exit from
289 the loop given our optimistic initialization of LATER above. */
296 /* Note that we do not use the last allocated element for our queue,
297 as EXIT_BLOCK is never inserted into it. In fact the above allocation
298 of n_basic_blocks + 1 elements is not necessary. */
300 qend
= &worklist
[n_basic_blocks
];
301 qlen
= n_basic_blocks
;
303 /* Iterate until the worklist is empty. */
306 /* Take the first entry off the worklist. */
313 /* Compute the intersection of LATERIN for each incoming edge to B. */
314 sbitmap_ones (laterin
[bb
->index
]);
315 FOR_EACH_EDGE (e
, ei
, bb
->preds
)
316 sbitmap_a_and_b (laterin
[bb
->index
], laterin
[bb
->index
],
317 later
[(size_t)e
->aux
]);
319 /* Calculate LATER for all outgoing edges. */
320 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
321 if (sbitmap_union_of_diff_cg (later
[(size_t) e
->aux
],
322 earliest
[(size_t) e
->aux
],
323 laterin
[e
->src
->index
],
324 antloc
[e
->src
->index
])
325 /* If LATER for an outgoing edge was changed, then we need
326 to add the target of the outgoing edge to the worklist. */
327 && e
->dest
!= EXIT_BLOCK_PTR
&& e
->dest
->aux
== 0)
337 /* Computation of insertion and deletion points requires computing LATERIN
338 for the EXIT block. We allocated an extra entry in the LATERIN array
339 for just this purpose. */
340 sbitmap_ones (laterin
[last_basic_block
]);
341 FOR_EACH_EDGE (e
, ei
, EXIT_BLOCK_PTR
->preds
)
342 sbitmap_a_and_b (laterin
[last_basic_block
],
343 laterin
[last_basic_block
],
344 later
[(size_t) e
->aux
]);
346 clear_aux_for_edges ();
350 /* Compute the insertion and deletion points for edge based LCM. */
353 compute_insert_delete (struct edge_list
*edge_list
, sbitmap
*antloc
,
354 sbitmap
*later
, sbitmap
*laterin
, sbitmap
*insert
,
361 sbitmap_difference (delete[bb
->index
], antloc
[bb
->index
],
364 for (x
= 0; x
< NUM_EDGES (edge_list
); x
++)
366 basic_block b
= INDEX_EDGE_SUCC_BB (edge_list
, x
);
368 if (b
== EXIT_BLOCK_PTR
)
369 sbitmap_difference (insert
[x
], later
[x
], laterin
[last_basic_block
]);
371 sbitmap_difference (insert
[x
], later
[x
], laterin
[b
->index
]);
375 /* Given local properties TRANSP, ANTLOC, AVOUT, KILL return the insert and
376 delete vectors for edge based LCM. Returns an edgelist which is used to
377 map the insert vector to what edge an expression should be inserted on. */
380 pre_edge_lcm (FILE *file ATTRIBUTE_UNUSED
, int n_exprs
, sbitmap
*transp
,
381 sbitmap
*avloc
, sbitmap
*antloc
, sbitmap
*kill
,
382 sbitmap
**insert
, sbitmap
**delete)
384 sbitmap
*antin
, *antout
, *earliest
;
385 sbitmap
*avin
, *avout
;
386 sbitmap
*later
, *laterin
;
387 struct edge_list
*edge_list
;
390 edge_list
= create_edge_list ();
391 num_edges
= NUM_EDGES (edge_list
);
393 #ifdef LCM_DEBUG_INFO
396 fprintf (file
, "Edge List:\n");
397 verify_edge_list (file
, edge_list
);
398 print_edge_list (file
, edge_list
);
399 dump_sbitmap_vector (file
, "transp", "", transp
, last_basic_block
);
400 dump_sbitmap_vector (file
, "antloc", "", antloc
, last_basic_block
);
401 dump_sbitmap_vector (file
, "avloc", "", avloc
, last_basic_block
);
402 dump_sbitmap_vector (file
, "kill", "", kill
, last_basic_block
);
406 /* Compute global availability. */
407 avin
= sbitmap_vector_alloc (last_basic_block
, n_exprs
);
408 avout
= sbitmap_vector_alloc (last_basic_block
, n_exprs
);
409 compute_available (avloc
, kill
, avout
, avin
);
410 sbitmap_vector_free (avin
);
412 /* Compute global anticipatability. */
413 antin
= sbitmap_vector_alloc (last_basic_block
, n_exprs
);
414 antout
= sbitmap_vector_alloc (last_basic_block
, n_exprs
);
415 compute_antinout_edge (antloc
, transp
, antin
, antout
);
417 #ifdef LCM_DEBUG_INFO
420 dump_sbitmap_vector (file
, "antin", "", antin
, last_basic_block
);
421 dump_sbitmap_vector (file
, "antout", "", antout
, last_basic_block
);
425 /* Compute earliestness. */
426 earliest
= sbitmap_vector_alloc (num_edges
, n_exprs
);
427 compute_earliest (edge_list
, n_exprs
, antin
, antout
, avout
, kill
, earliest
);
429 #ifdef LCM_DEBUG_INFO
431 dump_sbitmap_vector (file
, "earliest", "", earliest
, num_edges
);
434 sbitmap_vector_free (antout
);
435 sbitmap_vector_free (antin
);
436 sbitmap_vector_free (avout
);
438 later
= sbitmap_vector_alloc (num_edges
, n_exprs
);
440 /* Allocate an extra element for the exit block in the laterin vector. */
441 laterin
= sbitmap_vector_alloc (last_basic_block
+ 1, n_exprs
);
442 compute_laterin (edge_list
, earliest
, antloc
, later
, laterin
);
444 #ifdef LCM_DEBUG_INFO
447 dump_sbitmap_vector (file
, "laterin", "", laterin
, last_basic_block
+ 1);
448 dump_sbitmap_vector (file
, "later", "", later
, num_edges
);
452 sbitmap_vector_free (earliest
);
454 *insert
= sbitmap_vector_alloc (num_edges
, n_exprs
);
455 *delete = sbitmap_vector_alloc (last_basic_block
, n_exprs
);
456 compute_insert_delete (edge_list
, antloc
, later
, laterin
, *insert
, *delete);
458 sbitmap_vector_free (laterin
);
459 sbitmap_vector_free (later
);
461 #ifdef LCM_DEBUG_INFO
464 dump_sbitmap_vector (file
, "pre_insert_map", "", *insert
, num_edges
);
465 dump_sbitmap_vector (file
, "pre_delete_map", "", *delete,
473 /* Compute the AVIN and AVOUT vectors from the AVLOC and KILL vectors.
474 Return the number of passes we performed to iterate to a solution. */
477 compute_available (sbitmap
*avloc
, sbitmap
*kill
, sbitmap
*avout
,
481 basic_block
*worklist
, *qin
, *qout
, *qend
, bb
;
485 /* Allocate a worklist array/queue. Entries are only added to the
486 list if they were not already on the list. So the size is
487 bounded by the number of basic blocks. */
488 qin
= qout
= worklist
= xmalloc (sizeof (basic_block
) * n_basic_blocks
);
490 /* We want a maximal solution. */
491 sbitmap_vector_ones (avout
, last_basic_block
);
493 /* Put every block on the worklist; this is necessary because of the
494 optimistic initialization of AVOUT above. */
502 qend
= &worklist
[n_basic_blocks
];
503 qlen
= n_basic_blocks
;
505 /* Mark blocks which are successors of the entry block so that we
506 can easily identify them below. */
507 FOR_EACH_EDGE (e
, ei
, ENTRY_BLOCK_PTR
->succs
)
508 e
->dest
->aux
= ENTRY_BLOCK_PTR
;
510 /* Iterate until the worklist is empty. */
513 /* Take the first entry off the worklist. */
520 /* If one of the predecessor blocks is the ENTRY block, then the
521 intersection of avouts is the null set. We can identify such blocks
522 by the special value in the AUX field in the block structure. */
523 if (bb
->aux
== ENTRY_BLOCK_PTR
)
524 /* Do not clear the aux field for blocks which are successors of the
525 ENTRY block. That way we never add then to the worklist again. */
526 sbitmap_zero (avin
[bb
->index
]);
529 /* Clear the aux field of this block so that it can be added to
530 the worklist again if necessary. */
532 sbitmap_intersection_of_preds (avin
[bb
->index
], avout
, bb
->index
);
535 if (sbitmap_union_of_diff_cg (avout
[bb
->index
], avloc
[bb
->index
],
536 avin
[bb
->index
], kill
[bb
->index
]))
537 /* If the out state of this block changed, then we need
538 to add the successors of this block to the worklist
539 if they are not already on the worklist. */
540 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
541 if (!e
->dest
->aux
&& e
->dest
!= EXIT_BLOCK_PTR
)
552 clear_aux_for_edges ();
553 clear_aux_for_blocks ();
557 /* Compute the farthest vector for edge based lcm. */
560 compute_farthest (struct edge_list
*edge_list
, int n_exprs
,
561 sbitmap
*st_avout
, sbitmap
*st_avin
, sbitmap
*st_antin
,
562 sbitmap
*kill
, sbitmap
*farthest
)
564 sbitmap difference
, temp_bitmap
;
566 basic_block pred
, succ
;
568 num_edges
= NUM_EDGES (edge_list
);
570 difference
= sbitmap_alloc (n_exprs
);
571 temp_bitmap
= sbitmap_alloc (n_exprs
);
573 for (x
= 0; x
< num_edges
; x
++)
575 pred
= INDEX_EDGE_PRED_BB (edge_list
, x
);
576 succ
= INDEX_EDGE_SUCC_BB (edge_list
, x
);
577 if (succ
== EXIT_BLOCK_PTR
)
578 sbitmap_copy (farthest
[x
], st_avout
[pred
->index
]);
581 if (pred
== ENTRY_BLOCK_PTR
)
582 sbitmap_zero (farthest
[x
]);
585 sbitmap_difference (difference
, st_avout
[pred
->index
],
586 st_antin
[succ
->index
]);
587 sbitmap_not (temp_bitmap
, st_avin
[succ
->index
]);
588 sbitmap_a_and_b_or_c (farthest
[x
], difference
,
589 kill
[succ
->index
], temp_bitmap
);
594 sbitmap_free (temp_bitmap
);
595 sbitmap_free (difference
);
598 /* Compute nearer and nearerout vectors for edge based lcm.
600 This is the mirror of compute_laterin, additional comments on the
601 implementation can be found before compute_laterin. */
604 compute_nearerout (struct edge_list
*edge_list
, sbitmap
*farthest
,
605 sbitmap
*st_avloc
, sbitmap
*nearer
, sbitmap
*nearerout
)
609 basic_block
*worklist
, *tos
, bb
;
612 num_edges
= NUM_EDGES (edge_list
);
614 /* Allocate a worklist array/queue. Entries are only added to the
615 list if they were not already on the list. So the size is
616 bounded by the number of basic blocks. */
617 tos
= worklist
= xmalloc (sizeof (basic_block
) * (n_basic_blocks
+ 1));
619 /* Initialize NEARER for each edge and build a mapping from an edge to
621 for (i
= 0; i
< num_edges
; i
++)
622 INDEX_EDGE (edge_list
, i
)->aux
= (void *) (size_t) i
;
624 /* We want a maximal solution. */
625 sbitmap_vector_ones (nearer
, num_edges
);
627 /* Note that even though we want an optimistic setting of NEARER, we
628 do not want to be overly optimistic. Consider an incoming edge to
629 the exit block. That edge should always have a NEARER value the
630 same as FARTHEST for that edge. */
631 FOR_EACH_EDGE (e
, ei
, EXIT_BLOCK_PTR
->preds
)
632 sbitmap_copy (nearer
[(size_t)e
->aux
], farthest
[(size_t)e
->aux
]);
634 /* Add all the blocks to the worklist. This prevents an early exit
635 from the loop given our optimistic initialization of NEARER. */
642 /* Iterate until the worklist is empty. */
643 while (tos
!= worklist
)
645 /* Take the first entry off the worklist. */
649 /* Compute the intersection of NEARER for each outgoing edge from B. */
650 sbitmap_ones (nearerout
[bb
->index
]);
651 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
652 sbitmap_a_and_b (nearerout
[bb
->index
], nearerout
[bb
->index
],
653 nearer
[(size_t) e
->aux
]);
655 /* Calculate NEARER for all incoming edges. */
656 FOR_EACH_EDGE (e
, ei
, bb
->preds
)
657 if (sbitmap_union_of_diff_cg (nearer
[(size_t) e
->aux
],
658 farthest
[(size_t) e
->aux
],
659 nearerout
[e
->dest
->index
],
660 st_avloc
[e
->dest
->index
])
661 /* If NEARER for an incoming edge was changed, then we need
662 to add the source of the incoming edge to the worklist. */
663 && e
->src
!= ENTRY_BLOCK_PTR
&& e
->src
->aux
== 0)
670 /* Computation of insertion and deletion points requires computing NEAREROUT
671 for the ENTRY block. We allocated an extra entry in the NEAREROUT array
672 for just this purpose. */
673 sbitmap_ones (nearerout
[last_basic_block
]);
674 FOR_EACH_EDGE (e
, ei
, ENTRY_BLOCK_PTR
->succs
)
675 sbitmap_a_and_b (nearerout
[last_basic_block
],
676 nearerout
[last_basic_block
],
677 nearer
[(size_t) e
->aux
]);
679 clear_aux_for_edges ();
683 /* Compute the insertion and deletion points for edge based LCM. */
686 compute_rev_insert_delete (struct edge_list
*edge_list
, sbitmap
*st_avloc
,
687 sbitmap
*nearer
, sbitmap
*nearerout
,
688 sbitmap
*insert
, sbitmap
*delete)
694 sbitmap_difference (delete[bb
->index
], st_avloc
[bb
->index
],
695 nearerout
[bb
->index
]);
697 for (x
= 0; x
< NUM_EDGES (edge_list
); x
++)
699 basic_block b
= INDEX_EDGE_PRED_BB (edge_list
, x
);
700 if (b
== ENTRY_BLOCK_PTR
)
701 sbitmap_difference (insert
[x
], nearer
[x
], nearerout
[last_basic_block
]);
703 sbitmap_difference (insert
[x
], nearer
[x
], nearerout
[b
->index
]);
707 /* Given local properties TRANSP, ST_AVLOC, ST_ANTLOC, KILL return the
708 insert and delete vectors for edge based reverse LCM. Returns an
709 edgelist which is used to map the insert vector to what edge
710 an expression should be inserted on. */
713 pre_edge_rev_lcm (FILE *file ATTRIBUTE_UNUSED
, int n_exprs
, sbitmap
*transp
,
714 sbitmap
*st_avloc
, sbitmap
*st_antloc
, sbitmap
*kill
,
715 sbitmap
**insert
, sbitmap
**delete)
717 sbitmap
*st_antin
, *st_antout
;
718 sbitmap
*st_avout
, *st_avin
, *farthest
;
719 sbitmap
*nearer
, *nearerout
;
720 struct edge_list
*edge_list
;
723 edge_list
= create_edge_list ();
724 num_edges
= NUM_EDGES (edge_list
);
726 st_antin
= sbitmap_vector_alloc (last_basic_block
, n_exprs
);
727 st_antout
= sbitmap_vector_alloc (last_basic_block
, n_exprs
);
728 sbitmap_vector_zero (st_antin
, last_basic_block
);
729 sbitmap_vector_zero (st_antout
, last_basic_block
);
730 compute_antinout_edge (st_antloc
, transp
, st_antin
, st_antout
);
732 /* Compute global anticipatability. */
733 st_avout
= sbitmap_vector_alloc (last_basic_block
, n_exprs
);
734 st_avin
= sbitmap_vector_alloc (last_basic_block
, n_exprs
);
735 compute_available (st_avloc
, kill
, st_avout
, st_avin
);
737 #ifdef LCM_DEBUG_INFO
740 fprintf (file
, "Edge List:\n");
741 verify_edge_list (file
, edge_list
);
742 print_edge_list (file
, edge_list
);
743 dump_sbitmap_vector (file
, "transp", "", transp
, last_basic_block
);
744 dump_sbitmap_vector (file
, "st_avloc", "", st_avloc
, last_basic_block
);
745 dump_sbitmap_vector (file
, "st_antloc", "", st_antloc
, last_basic_block
);
746 dump_sbitmap_vector (file
, "st_antin", "", st_antin
, last_basic_block
);
747 dump_sbitmap_vector (file
, "st_antout", "", st_antout
, last_basic_block
);
748 dump_sbitmap_vector (file
, "st_kill", "", kill
, last_basic_block
);
752 #ifdef LCM_DEBUG_INFO
755 dump_sbitmap_vector (file
, "st_avout", "", st_avout
, last_basic_block
);
756 dump_sbitmap_vector (file
, "st_avin", "", st_avin
, last_basic_block
);
760 /* Compute farthestness. */
761 farthest
= sbitmap_vector_alloc (num_edges
, n_exprs
);
762 compute_farthest (edge_list
, n_exprs
, st_avout
, st_avin
, st_antin
,
765 #ifdef LCM_DEBUG_INFO
767 dump_sbitmap_vector (file
, "farthest", "", farthest
, num_edges
);
770 sbitmap_vector_free (st_antin
);
771 sbitmap_vector_free (st_antout
);
773 sbitmap_vector_free (st_avin
);
774 sbitmap_vector_free (st_avout
);
776 nearer
= sbitmap_vector_alloc (num_edges
, n_exprs
);
778 /* Allocate an extra element for the entry block. */
779 nearerout
= sbitmap_vector_alloc (last_basic_block
+ 1, n_exprs
);
780 compute_nearerout (edge_list
, farthest
, st_avloc
, nearer
, nearerout
);
782 #ifdef LCM_DEBUG_INFO
785 dump_sbitmap_vector (file
, "nearerout", "", nearerout
,
786 last_basic_block
+ 1);
787 dump_sbitmap_vector (file
, "nearer", "", nearer
, num_edges
);
791 sbitmap_vector_free (farthest
);
793 *insert
= sbitmap_vector_alloc (num_edges
, n_exprs
);
794 *delete = sbitmap_vector_alloc (last_basic_block
, n_exprs
);
795 compute_rev_insert_delete (edge_list
, st_avloc
, nearer
, nearerout
,
798 sbitmap_vector_free (nearerout
);
799 sbitmap_vector_free (nearer
);
801 #ifdef LCM_DEBUG_INFO
804 dump_sbitmap_vector (file
, "pre_insert_map", "", *insert
, num_edges
);
805 dump_sbitmap_vector (file
, "pre_delete_map", "", *delete,
814 The algorithm for setting the modes consists of scanning the insn list
815 and finding all the insns which require a specific mode. Each insn gets
816 a unique struct seginfo element. These structures are inserted into a list
817 for each basic block. For each entity, there is an array of bb_info over
818 the flow graph basic blocks (local var 'bb_info'), and contains a list
819 of all insns within that basic block, in the order they are encountered.
821 For each entity, any basic block WITHOUT any insns requiring a specific
822 mode are given a single entry, without a mode. (Each basic block
823 in the flow graph must have at least one entry in the segment table.)
825 The LCM algorithm is then run over the flow graph to determine where to
826 place the sets to the highest-priority value in respect of first the first
827 insn in any one block. Any adjustments required to the transparency
828 vectors are made, then the next iteration starts for the next-lower
829 priority mode, till for each entity all modes are exhausted.
831 More details are located in the code for optimize_mode_switching(). */
833 /* This structure contains the information for each insn which requires
834 either single or double mode to be set.
835 MODE is the mode this insn must be executed in.
836 INSN_PTR is the insn to be executed (may be the note that marks the
837 beginning of a basic block).
838 BBNUM is the flow graph basic block this insn occurs in.
839 NEXT is the next insn in the same basic block. */
845 struct seginfo
*next
;
846 HARD_REG_SET regs_live
;
851 struct seginfo
*seginfo
;
855 /* These bitmaps are used for the LCM algorithm. */
857 #ifdef OPTIMIZE_MODE_SWITCHING
858 static sbitmap
*antic
;
859 static sbitmap
*transp
;
860 static sbitmap
*comp
;
862 static struct seginfo
* new_seginfo (int, rtx
, int, HARD_REG_SET
);
863 static void add_seginfo (struct bb_info
*, struct seginfo
*);
864 static void reg_dies (rtx
, HARD_REG_SET
);
865 static void reg_becomes_live (rtx
, rtx
, void *);
866 static void make_preds_opaque (basic_block
, int);
869 #ifdef OPTIMIZE_MODE_SWITCHING
871 /* This function will allocate a new BBINFO structure, initialized
872 with the MODE, INSN, and basic block BB parameters. */
874 static struct seginfo
*
875 new_seginfo (int mode
, rtx insn
, int bb
, HARD_REG_SET regs_live
)
878 ptr
= xmalloc (sizeof (struct seginfo
));
880 ptr
->insn_ptr
= insn
;
883 COPY_HARD_REG_SET (ptr
->regs_live
, regs_live
);
887 /* Add a seginfo element to the end of a list.
888 HEAD is a pointer to the list beginning.
889 INFO is the structure to be linked in. */
892 add_seginfo (struct bb_info
*head
, struct seginfo
*info
)
896 if (head
->seginfo
== NULL
)
897 head
->seginfo
= info
;
901 while (ptr
->next
!= NULL
)
907 /* Make all predecessors of basic block B opaque, recursively, till we hit
908 some that are already non-transparent, or an edge where aux is set; that
909 denotes that a mode set is to be done on that edge.
910 J is the bit number in the bitmaps that corresponds to the entity that
911 we are currently handling mode-switching for. */
914 make_preds_opaque (basic_block b
, int j
)
919 FOR_EACH_EDGE (e
, ei
, b
->preds
)
921 basic_block pb
= e
->src
;
923 if (e
->aux
|| ! TEST_BIT (transp
[pb
->index
], j
))
926 RESET_BIT (transp
[pb
->index
], j
);
927 make_preds_opaque (pb
, j
);
931 /* Record in LIVE that register REG died. */
934 reg_dies (rtx reg
, HARD_REG_SET live
)
942 if (regno
< FIRST_PSEUDO_REGISTER
)
943 for (nregs
= hard_regno_nregs
[regno
][GET_MODE (reg
)] - 1; nregs
>= 0;
945 CLEAR_HARD_REG_BIT (live
, regno
+ nregs
);
948 /* Record in LIVE that register REG became live.
949 This is called via note_stores. */
952 reg_becomes_live (rtx reg
, rtx setter ATTRIBUTE_UNUSED
, void *live
)
956 if (GET_CODE (reg
) == SUBREG
)
957 reg
= SUBREG_REG (reg
);
963 if (regno
< FIRST_PSEUDO_REGISTER
)
964 for (nregs
= hard_regno_nregs
[regno
][GET_MODE (reg
)] - 1; nregs
>= 0;
966 SET_HARD_REG_BIT (* (HARD_REG_SET
*) live
, regno
+ nregs
);
969 /* Make sure if MODE_ENTRY is defined the MODE_EXIT is defined
971 #if defined (MODE_ENTRY) != defined (MODE_EXIT)
972 #error "Both MODE_ENTRY and MODE_EXIT must be defined"
975 #if defined (MODE_ENTRY) && defined (MODE_EXIT)
976 /* Split the fallthrough edge to the exit block, so that we can note
977 that there NORMAL_MODE is required. Return the new block if it's
978 inserted before the exit block. Otherwise return null. */
981 create_pre_exit (int n_entities
, int *entity_map
, const int *num_modes
)
985 basic_block pre_exit
;
987 /* The only non-call predecessor at this stage is a block with a
988 fallthrough edge; there can be at most one, but there could be
989 none at all, e.g. when exit is called. */
991 FOR_EACH_EDGE (eg
, ei
, EXIT_BLOCK_PTR
->preds
)
992 if (eg
->flags
& EDGE_FALLTHRU
)
994 basic_block src_bb
= eg
->src
;
995 regset live_at_end
= src_bb
->global_live_at_end
;
996 rtx last_insn
, ret_reg
;
998 gcc_assert (!pre_exit
);
999 /* If this function returns a value at the end, we have to
1000 insert the final mode switch before the return value copy
1001 to its hard register. */
1002 if (EDGE_COUNT (EXIT_BLOCK_PTR
->preds
) == 1
1003 && GET_CODE ((last_insn
= BB_END (src_bb
))) == INSN
1004 && GET_CODE (PATTERN (last_insn
)) == USE
1005 && GET_CODE ((ret_reg
= XEXP (PATTERN (last_insn
), 0))) == REG
)
1007 int ret_start
= REGNO (ret_reg
);
1008 int nregs
= hard_regno_nregs
[ret_start
][GET_MODE (ret_reg
)];
1009 int ret_end
= ret_start
+ nregs
;
1010 int short_block
= 0;
1011 int maybe_builtin_apply
= 0;
1012 int forced_late_switch
= 0;
1013 rtx before_return_copy
;
1017 rtx return_copy
= PREV_INSN (last_insn
);
1018 rtx return_copy_pat
, copy_reg
;
1019 int copy_start
, copy_num
;
1022 if (INSN_P (return_copy
))
1024 if (GET_CODE (PATTERN (return_copy
)) == USE
1025 && GET_CODE (XEXP (PATTERN (return_copy
), 0)) == REG
1026 && (FUNCTION_VALUE_REGNO_P
1027 (REGNO (XEXP (PATTERN (return_copy
), 0)))))
1029 maybe_builtin_apply
= 1;
1030 last_insn
= return_copy
;
1033 /* If the return register is not (in its entirety)
1034 likely spilled, the return copy might be
1035 partially or completely optimized away. */
1036 return_copy_pat
= single_set (return_copy
);
1037 if (!return_copy_pat
)
1039 return_copy_pat
= PATTERN (return_copy
);
1040 if (GET_CODE (return_copy_pat
) != CLOBBER
)
1043 copy_reg
= SET_DEST (return_copy_pat
);
1044 if (GET_CODE (copy_reg
) == REG
)
1045 copy_start
= REGNO (copy_reg
);
1046 else if (GET_CODE (copy_reg
) == SUBREG
1047 && GET_CODE (SUBREG_REG (copy_reg
)) == REG
)
1048 copy_start
= REGNO (SUBREG_REG (copy_reg
));
1051 if (copy_start
>= FIRST_PSEUDO_REGISTER
)
1054 = hard_regno_nregs
[copy_start
][GET_MODE (copy_reg
)];
1056 /* If the return register is not likely spilled, - as is
1057 the case for floating point on SH4 - then it might
1058 be set by an arithmetic operation that needs a
1059 different mode than the exit block. */
1060 for (j
= n_entities
- 1; j
>= 0; j
--)
1062 int e
= entity_map
[j
];
1063 int mode
= MODE_NEEDED (e
, return_copy
);
1065 if (mode
!= num_modes
[e
] && mode
!= MODE_EXIT (e
))
1070 /* For the SH4, floating point loads depend on fpscr,
1071 thus we might need to put the final mode switch
1072 after the return value copy. That is still OK,
1073 because a floating point return value does not
1074 conflict with address reloads. */
1075 if (copy_start
>= ret_start
1076 && copy_start
+ copy_num
<= ret_end
1077 && OBJECT_P (SET_SRC (return_copy_pat
)))
1078 forced_late_switch
= 1;
1082 if (copy_start
>= ret_start
1083 && copy_start
+ copy_num
<= ret_end
)
1085 else if (!maybe_builtin_apply
1086 || !FUNCTION_VALUE_REGNO_P (copy_start
))
1088 last_insn
= return_copy
;
1090 /* ??? Exception handling can lead to the return value
1091 copy being already separated from the return value use,
1092 as in unwind-dw2.c .
1093 Similarly, conditionally returning without a value,
1094 and conditionally using builtin_return can lead to an
1096 if (return_copy
== BB_HEAD (src_bb
))
1101 last_insn
= return_copy
;
1105 /* If we didn't see a full return value copy, verify that there
1106 is a plausible reason for this. If some, but not all of the
1107 return register is likely spilled, we can expect that there
1108 is a copy for the likely spilled part. */
1110 || forced_late_switch
1112 || !(CLASS_LIKELY_SPILLED_P
1113 (REGNO_REG_CLASS (ret_start
)))
1115 != hard_regno_nregs
[ret_start
][GET_MODE (ret_reg
)])
1116 /* For multi-hard-register floating point
1117 values, sometimes the likely-spilled part
1118 is ordinarily copied first, then the other
1119 part is set with an arithmetic operation.
1120 This doesn't actually cause reload
1121 failures, so let it pass. */
1122 || (GET_MODE_CLASS (GET_MODE (ret_reg
)) != MODE_INT
1125 if (INSN_P (last_insn
))
1128 = emit_note_before (NOTE_INSN_DELETED
, last_insn
);
1129 /* Instructions preceding LAST_INSN in the same block might
1130 require a different mode than MODE_EXIT, so if we might
1131 have such instructions, keep them in a separate block
1133 if (last_insn
!= BB_HEAD (src_bb
))
1134 src_bb
= split_block (src_bb
,
1135 PREV_INSN (before_return_copy
))->dest
;
1138 before_return_copy
= last_insn
;
1139 pre_exit
= split_block (src_bb
, before_return_copy
)->src
;
1143 pre_exit
= split_edge (eg
);
1144 COPY_REG_SET (pre_exit
->global_live_at_start
, live_at_end
);
1145 COPY_REG_SET (pre_exit
->global_live_at_end
, live_at_end
);
1153 /* Find all insns that need a particular mode setting, and insert the
1154 necessary mode switches. Return true if we did work. */
1157 optimize_mode_switching (FILE *file
)
1162 int need_commit
= 0;
1164 struct edge_list
*edge_list
;
1165 static const int num_modes
[] = NUM_MODES_FOR_MODE_SWITCHING
;
1166 #define N_ENTITIES ARRAY_SIZE (num_modes)
1167 int entity_map
[N_ENTITIES
];
1168 struct bb_info
*bb_info
[N_ENTITIES
];
1171 int max_num_modes
= 0;
1172 bool emited
= false;
1173 basic_block post_entry ATTRIBUTE_UNUSED
, pre_exit ATTRIBUTE_UNUSED
;
1177 for (e
= N_ENTITIES
- 1, n_entities
= 0; e
>= 0; e
--)
1178 if (OPTIMIZE_MODE_SWITCHING (e
))
1180 int entry_exit_extra
= 0;
1182 /* Create the list of segments within each basic block.
1183 If NORMAL_MODE is defined, allow for two extra
1184 blocks split from the entry and exit block. */
1185 #if defined (MODE_ENTRY) && defined (MODE_EXIT)
1186 entry_exit_extra
= 3;
1189 = xcalloc (last_basic_block
+ entry_exit_extra
, sizeof **bb_info
);
1190 entity_map
[n_entities
++] = e
;
1191 if (num_modes
[e
] > max_num_modes
)
1192 max_num_modes
= num_modes
[e
];
1198 #if defined (MODE_ENTRY) && defined (MODE_EXIT)
1199 /* Split the edge from the entry block, so that we can note that
1200 there NORMAL_MODE is supplied. */
1201 post_entry
= split_edge (single_succ_edge (ENTRY_BLOCK_PTR
));
1202 pre_exit
= create_pre_exit (n_entities
, entity_map
, num_modes
);
1205 /* Create the bitmap vectors. */
1207 antic
= sbitmap_vector_alloc (last_basic_block
, n_entities
);
1208 transp
= sbitmap_vector_alloc (last_basic_block
, n_entities
);
1209 comp
= sbitmap_vector_alloc (last_basic_block
, n_entities
);
1211 sbitmap_vector_ones (transp
, last_basic_block
);
1213 for (j
= n_entities
- 1; j
>= 0; j
--)
1215 int e
= entity_map
[j
];
1216 int no_mode
= num_modes
[e
];
1217 struct bb_info
*info
= bb_info
[j
];
1219 /* Determine what the first use (if any) need for a mode of entity E is.
1220 This will be the mode that is anticipatable for this block.
1221 Also compute the initial transparency settings. */
1224 struct seginfo
*ptr
;
1225 int last_mode
= no_mode
;
1226 HARD_REG_SET live_now
;
1228 REG_SET_TO_HARD_REG_SET (live_now
,
1229 bb
->global_live_at_start
);
1230 for (insn
= BB_HEAD (bb
);
1231 insn
!= NULL
&& insn
!= NEXT_INSN (BB_END (bb
));
1232 insn
= NEXT_INSN (insn
))
1236 int mode
= MODE_NEEDED (e
, insn
);
1239 if (mode
!= no_mode
&& mode
!= last_mode
)
1242 ptr
= new_seginfo (mode
, insn
, bb
->index
, live_now
);
1243 add_seginfo (info
+ bb
->index
, ptr
);
1244 RESET_BIT (transp
[bb
->index
], j
);
1247 last_mode
= MODE_AFTER (last_mode
, insn
);
1249 /* Update LIVE_NOW. */
1250 for (link
= REG_NOTES (insn
); link
; link
= XEXP (link
, 1))
1251 if (REG_NOTE_KIND (link
) == REG_DEAD
)
1252 reg_dies (XEXP (link
, 0), live_now
);
1254 note_stores (PATTERN (insn
), reg_becomes_live
, &live_now
);
1255 for (link
= REG_NOTES (insn
); link
; link
= XEXP (link
, 1))
1256 if (REG_NOTE_KIND (link
) == REG_UNUSED
)
1257 reg_dies (XEXP (link
, 0), live_now
);
1261 info
[bb
->index
].computing
= last_mode
;
1262 /* Check for blocks without ANY mode requirements. */
1263 if (last_mode
== no_mode
)
1265 ptr
= new_seginfo (no_mode
, BB_END (bb
), bb
->index
, live_now
);
1266 add_seginfo (info
+ bb
->index
, ptr
);
1269 #if defined (MODE_ENTRY) && defined (MODE_EXIT)
1271 int mode
= MODE_ENTRY (e
);
1273 if (mode
!= no_mode
)
1277 /* By always making this nontransparent, we save
1278 an extra check in make_preds_opaque. We also
1279 need this to avoid confusing pre_edge_lcm when
1280 antic is cleared but transp and comp are set. */
1281 RESET_BIT (transp
[bb
->index
], j
);
1283 /* Insert a fake computing definition of MODE into entry
1284 blocks which compute no mode. This represents the mode on
1286 info
[bb
->index
].computing
= mode
;
1289 info
[pre_exit
->index
].seginfo
->mode
= MODE_EXIT (e
);
1292 #endif /* NORMAL_MODE */
1295 kill
= sbitmap_vector_alloc (last_basic_block
, n_entities
);
1296 for (i
= 0; i
< max_num_modes
; i
++)
1298 int current_mode
[N_ENTITIES
];
1302 /* Set the anticipatable and computing arrays. */
1303 sbitmap_vector_zero (antic
, last_basic_block
);
1304 sbitmap_vector_zero (comp
, last_basic_block
);
1305 for (j
= n_entities
- 1; j
>= 0; j
--)
1307 int m
= current_mode
[j
] = MODE_PRIORITY_TO_MODE (entity_map
[j
], i
);
1308 struct bb_info
*info
= bb_info
[j
];
1312 if (info
[bb
->index
].seginfo
->mode
== m
)
1313 SET_BIT (antic
[bb
->index
], j
);
1315 if (info
[bb
->index
].computing
== m
)
1316 SET_BIT (comp
[bb
->index
], j
);
1320 /* Calculate the optimal locations for the
1321 placement mode switches to modes with priority I. */
1324 sbitmap_not (kill
[bb
->index
], transp
[bb
->index
]);
1325 edge_list
= pre_edge_lcm (file
, 1, transp
, comp
, antic
,
1326 kill
, &insert
, &delete);
1328 for (j
= n_entities
- 1; j
>= 0; j
--)
1330 /* Insert all mode sets that have been inserted by lcm. */
1331 int no_mode
= num_modes
[entity_map
[j
]];
1333 /* Wherever we have moved a mode setting upwards in the flow graph,
1334 the blocks between the new setting site and the now redundant
1335 computation ceases to be transparent for any lower-priority
1336 mode of the same entity. First set the aux field of each
1337 insertion site edge non-transparent, then propagate the new
1338 non-transparency from the redundant computation upwards till
1339 we hit an insertion site or an already non-transparent block. */
1340 for (e
= NUM_EDGES (edge_list
) - 1; e
>= 0; e
--)
1342 edge eg
= INDEX_EDGE (edge_list
, e
);
1345 HARD_REG_SET live_at_edge
;
1350 if (! TEST_BIT (insert
[e
], j
))
1353 eg
->aux
= (void *)1;
1355 mode
= current_mode
[j
];
1358 REG_SET_TO_HARD_REG_SET (live_at_edge
,
1359 src_bb
->global_live_at_end
);
1362 EMIT_MODE_SET (entity_map
[j
], mode
, live_at_edge
);
1363 mode_set
= get_insns ();
1366 /* Do not bother to insert empty sequence. */
1367 if (mode_set
== NULL_RTX
)
1370 /* If this is an abnormal edge, we'll insert at the end
1371 of the previous block. */
1372 if (eg
->flags
& EDGE_ABNORMAL
)
1375 if (JUMP_P (BB_END (src_bb
)))
1376 emit_insn_before (mode_set
, BB_END (src_bb
));
1379 /* It doesn't make sense to switch to normal
1380 mode after a CALL_INSN. The cases in which a
1381 CALL_INSN may have an abnormal edge are
1382 sibcalls and EH edges. In the case of
1383 sibcalls, the dest basic-block is the
1384 EXIT_BLOCK, that runs in normal mode; it is
1385 assumed that a sibcall insn requires normal
1386 mode itself, so no mode switch would be
1387 required after the call (it wouldn't make
1388 sense, anyway). In the case of EH edges, EH
1389 entry points also start in normal mode, so a
1390 similar reasoning applies. */
1391 gcc_assert (NONJUMP_INSN_P (BB_END (src_bb
)));
1392 emit_insn_after (mode_set
, BB_END (src_bb
));
1394 bb_info
[j
][src_bb
->index
].computing
= mode
;
1395 RESET_BIT (transp
[src_bb
->index
], j
);
1400 insert_insn_on_edge (mode_set
, eg
);
1404 FOR_EACH_BB_REVERSE (bb
)
1405 if (TEST_BIT (delete[bb
->index
], j
))
1407 make_preds_opaque (bb
, j
);
1408 /* Cancel the 'deleted' mode set. */
1409 bb_info
[j
][bb
->index
].seginfo
->mode
= no_mode
;
1413 sbitmap_vector_free (delete);
1414 sbitmap_vector_free (insert
);
1415 clear_aux_for_edges ();
1416 free_edge_list (edge_list
);
1419 /* Now output the remaining mode sets in all the segments. */
1420 for (j
= n_entities
- 1; j
>= 0; j
--)
1422 int no_mode
= num_modes
[entity_map
[j
]];
1424 FOR_EACH_BB_REVERSE (bb
)
1426 struct seginfo
*ptr
, *next
;
1427 for (ptr
= bb_info
[j
][bb
->index
].seginfo
; ptr
; ptr
= next
)
1430 if (ptr
->mode
!= no_mode
)
1435 EMIT_MODE_SET (entity_map
[j
], ptr
->mode
, ptr
->regs_live
);
1436 mode_set
= get_insns ();
1439 /* Insert MODE_SET only if it is nonempty. */
1440 if (mode_set
!= NULL_RTX
)
1443 if (NOTE_P (ptr
->insn_ptr
)
1444 && (NOTE_LINE_NUMBER (ptr
->insn_ptr
)
1445 == NOTE_INSN_BASIC_BLOCK
))
1446 emit_insn_after (mode_set
, ptr
->insn_ptr
);
1448 emit_insn_before (mode_set
, ptr
->insn_ptr
);
1459 /* Finished. Free up all the things we've allocated. */
1461 sbitmap_vector_free (kill
);
1462 sbitmap_vector_free (antic
);
1463 sbitmap_vector_free (transp
);
1464 sbitmap_vector_free (comp
);
1467 commit_edge_insertions ();
1469 #if defined (MODE_ENTRY) && defined (MODE_EXIT)
1470 cleanup_cfg (CLEANUP_NO_INSN_DEL
);
1472 if (!need_commit
&& !emited
)
1476 max_regno
= max_reg_num ();
1477 allocate_reg_info (max_regno
, FALSE
, FALSE
);
1478 update_life_info_in_dirty_blocks (UPDATE_LIFE_GLOBAL_RM_NOTES
,
1479 (PROP_DEATH_NOTES
| PROP_KILL_DEAD_CODE
1480 | PROP_SCAN_DEAD_CODE
));
1484 #endif /* OPTIMIZE_MODE_SWITCHING */