1 /* Build live ranges for pseudos.
2 Copyright (C) 2010-2015 Free Software Foundation, Inc.
3 Contributed by Vladimir Makarov <vmakarov@redhat.com>.
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 3, 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 COPYING3. If not see
19 <http://www.gnu.org/licenses/>. */
22 /* This file contains code to build pseudo live-ranges (analogous
23 structures used in IRA, so read comments about the live-ranges
24 there) and other info necessary for other passes to assign
25 hard-registers to pseudos, coalesce the spilled pseudos, and assign
26 stack memory slots to spilled pseudos. */
30 #include "coretypes.h"
32 #include "hard-reg-set.h"
35 #include "insn-config.h"
47 #include "statistics.h"
48 #include "double-int.h"
50 #include "fixed-value.h"
64 #include "dominance.h"
67 #include "basic-block.h"
71 #include "sparseset.h"
74 /* Program points are enumerated by numbers from range
75 0..LRA_LIVE_MAX_POINT-1. There are approximately two times more
76 program points than insns. Program points are places in the
77 program where liveness info can be changed. In most general case
78 (there are more complicated cases too) some program points
79 correspond to places where input operand dies and other ones
80 correspond to places where output operands are born. */
81 int lra_live_max_point
;
83 /* Accumulated execution frequency of all references for each hard
85 int lra_hard_reg_usage
[FIRST_PSEUDO_REGISTER
];
87 /* A global flag whose true value says to build live ranges for all
88 pseudos, otherwise the live ranges only for pseudos got memory is
89 build. True value means also building copies and setting up hard
90 register preferences. The complete info is necessary only for the
91 assignment pass. The complete info is not needed for the
92 coalescing and spill passes. */
93 static bool complete_info_p
;
95 /* Pseudos live at current point in the RTL scan. */
96 static sparseset pseudos_live
;
98 /* Pseudos probably living through calls and setjumps. As setjump is
99 a call too, if a bit in PSEUDOS_LIVE_THROUGH_SETJUMPS is set up
100 then the corresponding bit in PSEUDOS_LIVE_THROUGH_CALLS is set up
101 too. These data are necessary for cases when only one subreg of a
102 multi-reg pseudo is set up after a call. So we decide it is
103 probably live when traversing bb backward. We are sure about
104 living when we see its usage or definition of the pseudo. */
105 static sparseset pseudos_live_through_calls
;
106 static sparseset pseudos_live_through_setjumps
;
108 /* Set of hard regs (except eliminable ones) currently live. */
109 static HARD_REG_SET hard_regs_live
;
111 /* Set of pseudos and hard registers start living/dying in the current
112 insn. These sets are used to update REG_DEAD and REG_UNUSED notes
114 static sparseset start_living
, start_dying
;
116 /* Set of pseudos and hard regs dead and unused in the current
118 static sparseset unused_set
, dead_set
;
120 /* Bitmap used for holding intermediate bitmap operation results. */
121 static bitmap_head temp_bitmap
;
123 /* Pool for pseudo live ranges. */
124 static alloc_pool live_range_pool
;
126 /* Free live range LR. */
128 free_live_range (lra_live_range_t lr
)
130 pool_free (live_range_pool
, lr
);
133 /* Free live range list LR. */
135 free_live_range_list (lra_live_range_t lr
)
137 lra_live_range_t next
;
142 free_live_range (lr
);
147 /* Create and return pseudo live range with given attributes. */
148 static lra_live_range_t
149 create_live_range (int regno
, int start
, int finish
, lra_live_range_t next
)
153 p
= (lra_live_range_t
) pool_alloc (live_range_pool
);
161 /* Copy live range R and return the result. */
162 static lra_live_range_t
163 copy_live_range (lra_live_range_t r
)
167 p
= (lra_live_range_t
) pool_alloc (live_range_pool
);
172 /* Copy live range list given by its head R and return the result. */
174 lra_copy_live_range_list (lra_live_range_t r
)
176 lra_live_range_t p
, first
, *chain
;
179 for (chain
= &first
; r
!= NULL
; r
= r
->next
)
181 p
= copy_live_range (r
);
188 /* Merge *non-intersected* ranges R1 and R2 and returns the result.
189 The function maintains the order of ranges and tries to minimize
190 size of the result range list. Ranges R1 and R2 may not be used
193 lra_merge_live_ranges (lra_live_range_t r1
, lra_live_range_t r2
)
195 lra_live_range_t first
, last
, temp
;
201 for (first
= last
= NULL
; r1
!= NULL
&& r2
!= NULL
;)
203 if (r1
->start
< r2
->start
)
209 if (r1
->start
== r2
->finish
+ 1)
211 /* Joint ranges: merge r1 and r2 into r1. */
212 r1
->start
= r2
->start
;
215 pool_free (live_range_pool
, temp
);
219 gcc_assert (r2
->finish
+ 1 < r1
->start
);
220 /* Add r1 to the result. */
240 lra_assert (r2
!= NULL
);
249 /* Return TRUE if live ranges R1 and R2 intersect. */
251 lra_intersected_live_ranges_p (lra_live_range_t r1
, lra_live_range_t r2
)
253 /* Remember the live ranges are always kept ordered. */
254 while (r1
!= NULL
&& r2
!= NULL
)
256 if (r1
->start
> r2
->finish
)
258 else if (r2
->start
> r1
->finish
)
266 /* The function processing birth of hard register REGNO. It updates
267 living hard regs, START_LIVING, and conflict hard regs for living
268 pseudos. Conflict hard regs for the pic pseudo is not updated if
269 REGNO is REAL_PIC_OFFSET_TABLE_REGNUM and CHECK_PIC_PSEUDO_P is
272 make_hard_regno_born (int regno
, bool check_pic_pseudo_p ATTRIBUTE_UNUSED
)
276 lra_assert (regno
< FIRST_PSEUDO_REGISTER
);
277 if (TEST_HARD_REG_BIT (hard_regs_live
, regno
))
279 SET_HARD_REG_BIT (hard_regs_live
, regno
);
280 sparseset_set_bit (start_living
, regno
);
281 EXECUTE_IF_SET_IN_SPARSESET (pseudos_live
, i
)
282 #ifdef REAL_PIC_OFFSET_TABLE_REGNUM
283 if (! check_pic_pseudo_p
284 || regno
!= REAL_PIC_OFFSET_TABLE_REGNUM
285 || pic_offset_table_rtx
== NULL
286 || i
!= REGNO (pic_offset_table_rtx
))
288 SET_HARD_REG_BIT (lra_reg_info
[i
].conflict_hard_regs
, regno
);
291 /* Process the death of hard register REGNO. This updates
292 hard_regs_live and START_DYING. */
294 make_hard_regno_dead (int regno
)
296 lra_assert (regno
< FIRST_PSEUDO_REGISTER
);
297 if (! TEST_HARD_REG_BIT (hard_regs_live
, regno
))
299 sparseset_set_bit (start_dying
, regno
);
300 CLEAR_HARD_REG_BIT (hard_regs_live
, regno
);
303 /* Mark pseudo REGNO as living at program point POINT, update conflicting
304 hard registers of the pseudo and START_LIVING, and start a new live
305 range for the pseudo corresponding to REGNO if it is necessary. */
307 mark_pseudo_live (int regno
, int point
)
311 lra_assert (regno
>= FIRST_PSEUDO_REGISTER
);
312 lra_assert (! sparseset_bit_p (pseudos_live
, regno
));
313 sparseset_set_bit (pseudos_live
, regno
);
314 IOR_HARD_REG_SET (lra_reg_info
[regno
].conflict_hard_regs
, hard_regs_live
);
316 if ((complete_info_p
|| lra_get_regno_hard_regno (regno
) < 0)
317 && ((p
= lra_reg_info
[regno
].live_ranges
) == NULL
318 || (p
->finish
!= point
&& p
->finish
+ 1 != point
)))
319 lra_reg_info
[regno
].live_ranges
320 = create_live_range (regno
, point
, -1, p
);
321 sparseset_set_bit (start_living
, regno
);
324 /* Mark pseudo REGNO as not living at program point POINT and update
326 This finishes the current live range for the pseudo corresponding
329 mark_pseudo_dead (int regno
, int point
)
333 lra_assert (regno
>= FIRST_PSEUDO_REGISTER
);
334 lra_assert (sparseset_bit_p (pseudos_live
, regno
));
335 sparseset_clear_bit (pseudos_live
, regno
);
336 sparseset_set_bit (start_dying
, regno
);
337 if (complete_info_p
|| lra_get_regno_hard_regno (regno
) < 0)
339 p
= lra_reg_info
[regno
].live_ranges
;
340 lra_assert (p
!= NULL
);
345 /* The corresponding bitmaps of BB currently being processed. */
346 static bitmap bb_killed_pseudos
, bb_gen_pseudos
;
348 /* Mark register REGNO (pseudo or hard register) in MODE as live at
349 program point POINT. Update BB_GEN_PSEUDOS.
350 Return TRUE if the liveness tracking sets were modified, or FALSE
351 if nothing changed. */
353 mark_regno_live (int regno
, machine_mode mode
, int point
)
356 bool changed
= false;
358 if (regno
< FIRST_PSEUDO_REGISTER
)
360 for (last
= regno
+ hard_regno_nregs
[regno
][mode
];
363 make_hard_regno_born (regno
, false);
367 if (! sparseset_bit_p (pseudos_live
, regno
))
369 mark_pseudo_live (regno
, point
);
372 bitmap_set_bit (bb_gen_pseudos
, regno
);
378 /* Mark register REGNO in MODE as dead at program point POINT. Update
379 BB_GEN_PSEUDOS and BB_KILLED_PSEUDOS. Return TRUE if the liveness
380 tracking sets were modified, or FALSE if nothing changed. */
382 mark_regno_dead (int regno
, machine_mode mode
, int point
)
385 bool changed
= false;
387 if (regno
< FIRST_PSEUDO_REGISTER
)
389 for (last
= regno
+ hard_regno_nregs
[regno
][mode
];
392 make_hard_regno_dead (regno
);
396 if (sparseset_bit_p (pseudos_live
, regno
))
398 mark_pseudo_dead (regno
, point
);
401 bitmap_clear_bit (bb_gen_pseudos
, regno
);
402 bitmap_set_bit (bb_killed_pseudos
, regno
);
409 /* This page contains code for making global live analysis of pseudos.
410 The code works only when pseudo live info is changed on a BB
411 border. That might be a consequence of some global transformations
412 in LRA, e.g. PIC pseudo reuse or rematerialization. */
414 /* Structure describing local BB data used for pseudo
416 struct bb_data_pseudos
418 /* Basic block about which the below data are. */
420 bitmap_head killed_pseudos
; /* pseudos killed in the BB. */
421 bitmap_head gen_pseudos
; /* pseudos generated in the BB. */
424 /* Array for all BB data. Indexed by the corresponding BB index. */
425 typedef struct bb_data_pseudos
*bb_data_t
;
427 /* All basic block data are referred through the following array. */
428 static bb_data_t bb_data
;
430 /* Two small functions for access to the bb data. */
431 static inline bb_data_t
432 get_bb_data (basic_block bb
)
434 return &bb_data
[(bb
)->index
];
437 static inline bb_data_t
438 get_bb_data_by_index (int index
)
440 return &bb_data
[index
];
443 /* Bitmap with all hard regs. */
444 static bitmap_head all_hard_regs_bitmap
;
446 /* The transfer function used by the DF equation solver to propagate
447 live info through block with BB_INDEX according to the following
450 bb.livein = (bb.liveout - bb.kill) OR bb.gen
453 live_trans_fun (int bb_index
)
455 basic_block bb
= get_bb_data_by_index (bb_index
)->bb
;
456 bitmap bb_liveout
= df_get_live_out (bb
);
457 bitmap bb_livein
= df_get_live_in (bb
);
458 bb_data_t bb_info
= get_bb_data (bb
);
460 bitmap_and_compl (&temp_bitmap
, bb_liveout
, &all_hard_regs_bitmap
);
461 return bitmap_ior_and_compl (bb_livein
, &bb_info
->gen_pseudos
,
462 &temp_bitmap
, &bb_info
->killed_pseudos
);
465 /* The confluence function used by the DF equation solver to set up
466 live info for a block BB without predecessor. */
468 live_con_fun_0 (basic_block bb
)
470 bitmap_and_into (df_get_live_out (bb
), &all_hard_regs_bitmap
);
473 /* The confluence function used by the DF equation solver to propagate
474 live info from successor to predecessor on edge E according to the
477 bb.liveout = 0 for entry block | OR (livein of successors)
480 live_con_fun_n (edge e
)
482 basic_block bb
= e
->src
;
483 basic_block dest
= e
->dest
;
484 bitmap bb_liveout
= df_get_live_out (bb
);
485 bitmap dest_livein
= df_get_live_in (dest
);
487 return bitmap_ior_and_compl_into (bb_liveout
,
488 dest_livein
, &all_hard_regs_bitmap
);
491 /* Indexes of all function blocks. */
492 static bitmap_head all_blocks
;
494 /* Allocate and initialize data needed for global pseudo live
497 initiate_live_solver (void)
499 bitmap_initialize (&all_hard_regs_bitmap
, ®_obstack
);
500 bitmap_set_range (&all_hard_regs_bitmap
, 0, FIRST_PSEUDO_REGISTER
);
501 bb_data
= XNEWVEC (struct bb_data_pseudos
, last_basic_block_for_fn (cfun
));
502 bitmap_initialize (&all_blocks
, ®_obstack
);
505 FOR_ALL_BB_FN (bb
, cfun
)
507 bb_data_t bb_info
= get_bb_data (bb
);
509 bitmap_initialize (&bb_info
->killed_pseudos
, ®_obstack
);
510 bitmap_initialize (&bb_info
->gen_pseudos
, ®_obstack
);
511 bitmap_set_bit (&all_blocks
, bb
->index
);
515 /* Free all data needed for global pseudo live analysis. */
517 finish_live_solver (void)
521 bitmap_clear (&all_blocks
);
522 FOR_ALL_BB_FN (bb
, cfun
)
524 bb_data_t bb_info
= get_bb_data (bb
);
525 bitmap_clear (&bb_info
->killed_pseudos
);
526 bitmap_clear (&bb_info
->gen_pseudos
);
529 bitmap_clear (&all_hard_regs_bitmap
);
534 /* Insn currently scanned. */
535 static rtx_insn
*curr_insn
;
537 static lra_insn_recog_data_t curr_id
;
538 /* The insn static data. */
539 static struct lra_static_insn_data
*curr_static_id
;
541 /* Return true when one of the predecessor edges of BB is marked with
542 EDGE_ABNORMAL_CALL or EDGE_EH. */
544 bb_has_abnormal_call_pred (basic_block bb
)
549 FOR_EACH_EDGE (e
, ei
, bb
->preds
)
551 if (e
->flags
& (EDGE_ABNORMAL_CALL
| EDGE_EH
))
557 /* Vec containing execution frequencies of program points. */
558 static vec
<int> point_freq_vec
;
560 /* The start of the above vector elements. */
563 /* Increment the current program point POINT to the next point which has
564 execution frequency FREQ. */
566 next_program_point (int &point
, int freq
)
568 point_freq_vec
.safe_push (freq
);
569 lra_point_freq
= point_freq_vec
.address ();
573 /* Update the preference of HARD_REGNO for pseudo REGNO by PROFIT. */
575 lra_setup_reload_pseudo_preferenced_hard_reg (int regno
,
576 int hard_regno
, int profit
)
578 lra_assert (regno
>= lra_constraint_new_regno_start
);
579 if (lra_reg_info
[regno
].preferred_hard_regno1
== hard_regno
)
580 lra_reg_info
[regno
].preferred_hard_regno_profit1
+= profit
;
581 else if (lra_reg_info
[regno
].preferred_hard_regno2
== hard_regno
)
582 lra_reg_info
[regno
].preferred_hard_regno_profit2
+= profit
;
583 else if (lra_reg_info
[regno
].preferred_hard_regno1
< 0)
585 lra_reg_info
[regno
].preferred_hard_regno1
= hard_regno
;
586 lra_reg_info
[regno
].preferred_hard_regno_profit1
= profit
;
588 else if (lra_reg_info
[regno
].preferred_hard_regno2
< 0
589 || profit
> lra_reg_info
[regno
].preferred_hard_regno_profit2
)
591 lra_reg_info
[regno
].preferred_hard_regno2
= hard_regno
;
592 lra_reg_info
[regno
].preferred_hard_regno_profit2
= profit
;
596 /* Keep the 1st hard regno as more profitable. */
597 if (lra_reg_info
[regno
].preferred_hard_regno1
>= 0
598 && lra_reg_info
[regno
].preferred_hard_regno2
>= 0
599 && (lra_reg_info
[regno
].preferred_hard_regno_profit2
600 > lra_reg_info
[regno
].preferred_hard_regno_profit1
))
604 temp
= lra_reg_info
[regno
].preferred_hard_regno1
;
605 lra_reg_info
[regno
].preferred_hard_regno1
606 = lra_reg_info
[regno
].preferred_hard_regno2
;
607 lra_reg_info
[regno
].preferred_hard_regno2
= temp
;
608 temp
= lra_reg_info
[regno
].preferred_hard_regno_profit1
;
609 lra_reg_info
[regno
].preferred_hard_regno_profit1
610 = lra_reg_info
[regno
].preferred_hard_regno_profit2
;
611 lra_reg_info
[regno
].preferred_hard_regno_profit2
= temp
;
613 if (lra_dump_file
!= NULL
)
615 if ((hard_regno
= lra_reg_info
[regno
].preferred_hard_regno1
) >= 0)
616 fprintf (lra_dump_file
,
617 " Hard reg %d is preferable by r%d with profit %d\n",
619 lra_reg_info
[regno
].preferred_hard_regno_profit1
);
620 if ((hard_regno
= lra_reg_info
[regno
].preferred_hard_regno2
) >= 0)
621 fprintf (lra_dump_file
,
622 " Hard reg %d is preferable by r%d with profit %d\n",
624 lra_reg_info
[regno
].preferred_hard_regno_profit2
);
628 /* Check that REGNO living through calls and setjumps, set up conflict
629 regs, and clear corresponding bits in PSEUDOS_LIVE_THROUGH_CALLS and
630 PSEUDOS_LIVE_THROUGH_SETJUMPS. */
632 check_pseudos_live_through_calls (int regno
)
636 if (! sparseset_bit_p (pseudos_live_through_calls
, regno
))
638 sparseset_clear_bit (pseudos_live_through_calls
, regno
);
639 bool actual_call_used_reg_set_available_p
640 = !hard_reg_set_empty_p (lra_reg_info
[regno
].actual_call_used_reg_set
);
641 IOR_HARD_REG_SET (lra_reg_info
[regno
].conflict_hard_regs
,
642 (actual_call_used_reg_set_available_p
643 ? lra_reg_info
[regno
].actual_call_used_reg_set
644 : call_used_reg_set
));
646 for (hr
= 0; hr
< FIRST_PSEUDO_REGISTER
; hr
++)
647 if (HARD_REGNO_CALL_PART_CLOBBERED (hr
, PSEUDO_REGNO_MODE (regno
)))
648 SET_HARD_REG_BIT (lra_reg_info
[regno
].conflict_hard_regs
, hr
);
649 #ifdef ENABLE_CHECKING
650 lra_reg_info
[regno
].call_p
= true;
652 if (! sparseset_bit_p (pseudos_live_through_setjumps
, regno
))
654 sparseset_clear_bit (pseudos_live_through_setjumps
, regno
);
655 /* Don't allocate pseudos that cross setjmps or any call, if this
656 function receives a nonlocal goto. */
657 SET_HARD_REG_SET (lra_reg_info
[regno
].conflict_hard_regs
);
660 /* Process insns of the basic block BB to update pseudo live ranges,
661 pseudo hard register conflicts, and insn notes. We do it on
662 backward scan of BB insns. CURR_POINT is the program point where
663 BB ends. The function updates this counter and returns in
664 CURR_POINT the program point where BB starts. The function also
665 does local live info updates and can delete the dead insns if
666 DEAD_INSN_P. It returns true if pseudo live info was
667 changed at the BB start. */
669 process_bb_lives (basic_block bb
, int &curr_point
, bool dead_insn_p
)
678 bool need_curr_point_incr
;
680 reg_live_out
= df_get_live_out (bb
);
681 sparseset_clear (pseudos_live
);
682 sparseset_clear (pseudos_live_through_calls
);
683 sparseset_clear (pseudos_live_through_setjumps
);
684 REG_SET_TO_HARD_REG_SET (hard_regs_live
, reg_live_out
);
685 AND_COMPL_HARD_REG_SET (hard_regs_live
, eliminable_regset
);
686 EXECUTE_IF_SET_IN_BITMAP (reg_live_out
, FIRST_PSEUDO_REGISTER
, j
, bi
)
687 mark_pseudo_live (j
, curr_point
);
689 bb_gen_pseudos
= &get_bb_data (bb
)->gen_pseudos
;
690 bb_killed_pseudos
= &get_bb_data (bb
)->killed_pseudos
;
691 bitmap_clear (bb_gen_pseudos
);
692 bitmap_clear (bb_killed_pseudos
);
693 freq
= REG_FREQ_FROM_BB (bb
);
695 if (lra_dump_file
!= NULL
)
696 fprintf (lra_dump_file
, " BB %d\n", bb
->index
);
698 /* Scan the code of this basic block, noting which pseudos and hard
699 regs are born or die.
701 Note that this loop treats uninitialized values as live until the
702 beginning of the block. For example, if an instruction uses
703 (reg:DI foo), and only (subreg:SI (reg:DI foo) 0) is ever set,
704 FOO will remain live until the beginning of the block. Likewise
705 if FOO is not set at all. This is unnecessarily pessimistic, but
706 it probably doesn't matter much in practice. */
707 FOR_BB_INSNS_REVERSE_SAFE (bb
, curr_insn
, next
)
710 int dst_regno
, src_regno
;
712 struct lra_insn_reg
*reg
;
714 if (!NONDEBUG_INSN_P (curr_insn
))
717 curr_id
= lra_get_insn_recog_data (curr_insn
);
718 curr_static_id
= curr_id
->insn_static_data
;
719 if (lra_dump_file
!= NULL
)
720 fprintf (lra_dump_file
, " Insn %u: point = %d\n",
721 INSN_UID (curr_insn
), curr_point
);
723 set
= single_set (curr_insn
);
725 if (dead_insn_p
&& set
!= NULL_RTX
726 && REG_P (SET_DEST (set
)) && REGNO (SET_DEST (set
)) >= FIRST_PSEUDO_REGISTER
727 && find_reg_note (curr_insn
, REG_EH_REGION
, NULL_RTX
) == NULL_RTX
728 && ! may_trap_p (PATTERN (curr_insn
))
729 /* Don't do premature remove of pic offset pseudo as we can
730 start to use it after some reload generation. */
731 && (pic_offset_table_rtx
== NULL_RTX
732 || pic_offset_table_rtx
!= SET_DEST (set
)))
734 bool remove_p
= true;
736 for (reg
= curr_id
->regs
; reg
!= NULL
; reg
= reg
->next
)
737 if (reg
->type
!= OP_IN
&& sparseset_bit_p (pseudos_live
, reg
->regno
))
742 for (reg
= curr_static_id
->hard_regs
; reg
!= NULL
; reg
= reg
->next
)
743 if (reg
->type
!= OP_IN
)
748 if (remove_p
&& ! volatile_refs_p (PATTERN (curr_insn
)))
750 dst_regno
= REGNO (SET_DEST (set
));
751 if (lra_dump_file
!= NULL
)
752 fprintf (lra_dump_file
, " Deleting dead insn %u\n",
753 INSN_UID (curr_insn
));
754 lra_set_insn_deleted (curr_insn
);
755 if (lra_reg_info
[dst_regno
].nrefs
== 0)
757 /* There might be some debug insns with the pseudo. */
761 bitmap_copy (&temp_bitmap
, &lra_reg_info
[dst_regno
].insn_bitmap
);
762 EXECUTE_IF_SET_IN_BITMAP (&temp_bitmap
, 0, uid
, bi
)
764 insn
= lra_insn_recog_data
[uid
]->insn
;
765 lra_substitute_pseudo_within_insn (insn
, dst_regno
,
767 lra_update_insn_regno_info (insn
);
774 /* Update max ref width and hard reg usage. */
775 for (reg
= curr_id
->regs
; reg
!= NULL
; reg
= reg
->next
)
776 if (reg
->regno
>= FIRST_PSEUDO_REGISTER
777 && (GET_MODE_SIZE (reg
->biggest_mode
)
778 > GET_MODE_SIZE (lra_reg_info
[reg
->regno
].biggest_mode
)))
779 lra_reg_info
[reg
->regno
].biggest_mode
= reg
->biggest_mode
;
780 else if (reg
->regno
< FIRST_PSEUDO_REGISTER
)
781 lra_hard_reg_usage
[reg
->regno
] += freq
;
783 call_p
= CALL_P (curr_insn
);
786 && REG_P (SET_DEST (set
)) && REG_P (SET_SRC (set
))
787 /* Check that source regno does not conflict with
788 destination regno to exclude most impossible
790 && ((((src_regno
= REGNO (SET_SRC (set
))) >= FIRST_PSEUDO_REGISTER
791 && ! sparseset_bit_p (pseudos_live
, src_regno
))
792 || (src_regno
< FIRST_PSEUDO_REGISTER
793 && ! TEST_HARD_REG_BIT (hard_regs_live
, src_regno
)))
794 /* It might be 'inheritance pseudo <- reload pseudo'. */
795 || (src_regno
>= lra_constraint_new_regno_start
796 && ((int) REGNO (SET_DEST (set
))
797 >= lra_constraint_new_regno_start
)
798 /* Remember to skip special cases where src/dest regnos are
799 the same, e.g. insn SET pattern has matching constraints
801 && src_regno
!= (int) REGNO (SET_DEST (set
)))))
803 int hard_regno
= -1, regno
= -1;
805 dst_regno
= REGNO (SET_DEST (set
));
806 if (dst_regno
>= lra_constraint_new_regno_start
807 && src_regno
>= lra_constraint_new_regno_start
)
808 lra_create_copy (dst_regno
, src_regno
, freq
);
809 else if (dst_regno
>= lra_constraint_new_regno_start
)
811 if ((hard_regno
= src_regno
) >= FIRST_PSEUDO_REGISTER
)
812 hard_regno
= reg_renumber
[src_regno
];
815 else if (src_regno
>= lra_constraint_new_regno_start
)
817 if ((hard_regno
= dst_regno
) >= FIRST_PSEUDO_REGISTER
)
818 hard_regno
= reg_renumber
[dst_regno
];
821 if (regno
>= 0 && hard_regno
>= 0)
822 lra_setup_reload_pseudo_preferenced_hard_reg
823 (regno
, hard_regno
, freq
);
826 sparseset_clear (start_living
);
828 /* Try to avoid unnecessary program point increments, this saves
829 a lot of time in remove_some_program_points_and_update_live_ranges.
830 We only need an increment if something becomes live or dies at this
832 need_curr_point_incr
= false;
834 /* Mark each defined value as live. We need to do this for
835 unused values because they still conflict with quantities
836 that are live at the time of the definition. */
837 for (reg
= curr_id
->regs
; reg
!= NULL
; reg
= reg
->next
)
838 if (reg
->type
!= OP_IN
)
841 |= mark_regno_live (reg
->regno
, reg
->biggest_mode
,
843 check_pseudos_live_through_calls (reg
->regno
);
846 for (reg
= curr_static_id
->hard_regs
; reg
!= NULL
; reg
= reg
->next
)
847 if (reg
->type
!= OP_IN
)
848 make_hard_regno_born (reg
->regno
, false);
850 sparseset_copy (unused_set
, start_living
);
852 sparseset_clear (start_dying
);
854 /* See which defined values die here. */
855 for (reg
= curr_id
->regs
; reg
!= NULL
; reg
= reg
->next
)
856 if (reg
->type
== OP_OUT
&& ! reg
->early_clobber
&& ! reg
->subreg_p
)
858 |= mark_regno_dead (reg
->regno
, reg
->biggest_mode
,
861 for (reg
= curr_static_id
->hard_regs
; reg
!= NULL
; reg
= reg
->next
)
862 if (reg
->type
== OP_OUT
&& ! reg
->early_clobber
&& ! reg
->subreg_p
)
863 make_hard_regno_dead (reg
->regno
);
869 HARD_REG_SET this_call_used_reg_set
;
870 get_call_reg_set_usage (curr_insn
, &this_call_used_reg_set
,
873 EXECUTE_IF_SET_IN_SPARSESET (pseudos_live
, j
)
874 IOR_HARD_REG_SET (lra_reg_info
[j
].actual_call_used_reg_set
,
875 this_call_used_reg_set
);
878 sparseset_ior (pseudos_live_through_calls
,
879 pseudos_live_through_calls
, pseudos_live
);
880 if (cfun
->has_nonlocal_label
881 || find_reg_note (curr_insn
, REG_SETJMP
,
882 NULL_RTX
) != NULL_RTX
)
883 sparseset_ior (pseudos_live_through_setjumps
,
884 pseudos_live_through_setjumps
, pseudos_live
);
887 /* Increment the current program point if we must. */
888 if (need_curr_point_incr
)
889 next_program_point (curr_point
, freq
);
891 sparseset_clear (start_living
);
893 need_curr_point_incr
= false;
895 /* Mark each used value as live. */
896 for (reg
= curr_id
->regs
; reg
!= NULL
; reg
= reg
->next
)
897 if (reg
->type
== OP_IN
)
900 |= mark_regno_live (reg
->regno
, reg
->biggest_mode
,
902 check_pseudos_live_through_calls (reg
->regno
);
905 for (reg
= curr_static_id
->hard_regs
; reg
!= NULL
; reg
= reg
->next
)
906 if (reg
->type
== OP_IN
)
907 make_hard_regno_born (reg
->regno
, false);
909 if (curr_id
->arg_hard_regs
!= NULL
)
910 /* Make argument hard registers live. Don't create conflict
911 of used REAL_PIC_OFFSET_TABLE_REGNUM and the pic pseudo. */
912 for (i
= 0; (regno
= curr_id
->arg_hard_regs
[i
]) >= 0; i
++)
913 make_hard_regno_born (regno
, true);
915 sparseset_and_compl (dead_set
, start_living
, start_dying
);
917 /* Mark early clobber outputs dead. */
918 for (reg
= curr_id
->regs
; reg
!= NULL
; reg
= reg
->next
)
919 if (reg
->type
== OP_OUT
&& reg
->early_clobber
&& ! reg
->subreg_p
)
921 |= mark_regno_dead (reg
->regno
, reg
->biggest_mode
,
924 for (reg
= curr_static_id
->hard_regs
; reg
!= NULL
; reg
= reg
->next
)
925 if (reg
->type
== OP_OUT
&& reg
->early_clobber
&& ! reg
->subreg_p
)
926 make_hard_regno_dead (reg
->regno
);
928 if (need_curr_point_incr
)
929 next_program_point (curr_point
, freq
);
932 for (link_loc
= ®_NOTES (curr_insn
); (link
= *link_loc
) != NULL_RTX
;)
934 if (REG_NOTE_KIND (link
) != REG_DEAD
935 && REG_NOTE_KIND (link
) != REG_UNUSED
)
937 else if (REG_P (XEXP (link
, 0)))
939 regno
= REGNO (XEXP (link
, 0));
940 if ((REG_NOTE_KIND (link
) == REG_DEAD
941 && ! sparseset_bit_p (dead_set
, regno
))
942 || (REG_NOTE_KIND (link
) == REG_UNUSED
943 && ! sparseset_bit_p (unused_set
, regno
)))
945 *link_loc
= XEXP (link
, 1);
948 if (REG_NOTE_KIND (link
) == REG_DEAD
)
949 sparseset_clear_bit (dead_set
, regno
);
950 else if (REG_NOTE_KIND (link
) == REG_UNUSED
)
951 sparseset_clear_bit (unused_set
, regno
);
953 link_loc
= &XEXP (link
, 1);
955 EXECUTE_IF_SET_IN_SPARSESET (dead_set
, j
)
956 add_reg_note (curr_insn
, REG_DEAD
, regno_reg_rtx
[j
]);
957 EXECUTE_IF_SET_IN_SPARSESET (unused_set
, j
)
958 add_reg_note (curr_insn
, REG_UNUSED
, regno_reg_rtx
[j
]);
961 #ifdef EH_RETURN_DATA_REGNO
962 if (bb_has_eh_pred (bb
))
965 unsigned int regno
= EH_RETURN_DATA_REGNO (j
);
967 if (regno
== INVALID_REGNUM
)
969 make_hard_regno_born (regno
, false);
973 /* Pseudos can't go in stack regs at the start of a basic block that
974 is reached by an abnormal edge. Likewise for call clobbered regs,
975 because caller-save, fixup_abnormal_edges and possibly the table
976 driven EH machinery are not quite ready to handle such pseudos
977 live across such edges. */
978 if (bb_has_abnormal_pred (bb
))
981 EXECUTE_IF_SET_IN_SPARSESET (pseudos_live
, px
)
982 lra_reg_info
[px
].no_stack_p
= true;
983 for (px
= FIRST_STACK_REG
; px
<= LAST_STACK_REG
; px
++)
984 make_hard_regno_born (px
, false);
986 /* No need to record conflicts for call clobbered regs if we
987 have nonlocal labels around, as we don't ever try to
988 allocate such regs in this case. */
989 if (!cfun
->has_nonlocal_label
&& bb_has_abnormal_call_pred (bb
))
990 for (px
= 0; px
< FIRST_PSEUDO_REGISTER
; px
++)
991 if (call_used_regs
[px
])
992 make_hard_regno_born (px
, false);
995 bool live_change_p
= false;
996 /* Check if bb border live info was changed. */
997 unsigned int live_pseudos_num
= 0;
998 EXECUTE_IF_SET_IN_BITMAP (df_get_live_in (bb
),
999 FIRST_PSEUDO_REGISTER
, j
, bi
)
1002 if (! sparseset_bit_p (pseudos_live
, j
))
1004 live_change_p
= true;
1005 if (lra_dump_file
!= NULL
)
1006 fprintf (lra_dump_file
,
1007 " r%d is removed as live at bb%d start\n", j
, bb
->index
);
1012 && sparseset_cardinality (pseudos_live
) != live_pseudos_num
)
1014 live_change_p
= true;
1015 if (lra_dump_file
!= NULL
)
1016 EXECUTE_IF_SET_IN_SPARSESET (pseudos_live
, j
)
1017 if (! bitmap_bit_p (df_get_live_in (bb
), j
))
1018 fprintf (lra_dump_file
,
1019 " r%d is added to live at bb%d start\n", j
, bb
->index
);
1021 /* See if we'll need an increment at the end of this basic block.
1022 An increment is needed if the PSEUDOS_LIVE set is not empty,
1023 to make sure the finish points are set up correctly. */
1024 need_curr_point_incr
= (sparseset_cardinality (pseudos_live
) > 0);
1026 EXECUTE_IF_SET_IN_SPARSESET (pseudos_live
, i
)
1027 mark_pseudo_dead (i
, curr_point
);
1029 EXECUTE_IF_SET_IN_BITMAP (df_get_live_in (bb
), FIRST_PSEUDO_REGISTER
, j
, bi
)
1031 if (sparseset_cardinality (pseudos_live_through_calls
) == 0)
1033 if (sparseset_bit_p (pseudos_live_through_calls
, j
))
1034 check_pseudos_live_through_calls (j
);
1037 if (need_curr_point_incr
)
1038 next_program_point (curr_point
, freq
);
1040 return live_change_p
;
1043 /* Compress pseudo live ranges by removing program points where
1044 nothing happens. Complexity of many algorithms in LRA is linear
1045 function of program points number. To speed up the code we try to
1046 minimize the number of the program points here. */
1048 remove_some_program_points_and_update_live_ranges (void)
1053 lra_live_range_t r
, prev_r
, next_r
;
1054 sbitmap born_or_dead
, born
, dead
;
1055 sbitmap_iterator sbi
;
1056 bool born_p
, dead_p
, prev_born_p
, prev_dead_p
;
1058 born
= sbitmap_alloc (lra_live_max_point
);
1059 dead
= sbitmap_alloc (lra_live_max_point
);
1060 bitmap_clear (born
);
1061 bitmap_clear (dead
);
1062 max_regno
= max_reg_num ();
1063 for (i
= FIRST_PSEUDO_REGISTER
; i
< (unsigned) max_regno
; i
++)
1065 for (r
= lra_reg_info
[i
].live_ranges
; r
!= NULL
; r
= r
->next
)
1067 lra_assert (r
->start
<= r
->finish
);
1068 bitmap_set_bit (born
, r
->start
);
1069 bitmap_set_bit (dead
, r
->finish
);
1072 born_or_dead
= sbitmap_alloc (lra_live_max_point
);
1073 bitmap_ior (born_or_dead
, born
, dead
);
1074 map
= XCNEWVEC (int, lra_live_max_point
);
1076 prev_born_p
= prev_dead_p
= false;
1077 EXECUTE_IF_SET_IN_BITMAP (born_or_dead
, 0, i
, sbi
)
1079 born_p
= bitmap_bit_p (born
, i
);
1080 dead_p
= bitmap_bit_p (dead
, i
);
1081 if ((prev_born_p
&& ! prev_dead_p
&& born_p
&& ! dead_p
)
1082 || (prev_dead_p
&& ! prev_born_p
&& dead_p
&& ! born_p
))
1085 lra_point_freq
[n
] = MAX (lra_point_freq
[n
], lra_point_freq
[i
]);
1090 lra_point_freq
[n
] = lra_point_freq
[i
];
1092 prev_born_p
= born_p
;
1093 prev_dead_p
= dead_p
;
1095 sbitmap_free (born_or_dead
);
1096 sbitmap_free (born
);
1097 sbitmap_free (dead
);
1099 if (lra_dump_file
!= NULL
)
1100 fprintf (lra_dump_file
, "Compressing live ranges: from %d to %d - %d%%\n",
1101 lra_live_max_point
, n
, 100 * n
/ lra_live_max_point
);
1102 if (n
< lra_live_max_point
)
1104 lra_live_max_point
= n
;
1105 for (i
= FIRST_PSEUDO_REGISTER
; i
< (unsigned) max_regno
; i
++)
1107 for (prev_r
= NULL
, r
= lra_reg_info
[i
].live_ranges
;
1112 r
->start
= map
[r
->start
];
1113 r
->finish
= map
[r
->finish
];
1114 if (prev_r
== NULL
|| prev_r
->start
> r
->finish
+ 1)
1119 prev_r
->start
= r
->start
;
1120 prev_r
->next
= next_r
;
1121 free_live_range (r
);
1128 /* Print live ranges R to file F. */
1130 lra_print_live_range_list (FILE *f
, lra_live_range_t r
)
1132 for (; r
!= NULL
; r
= r
->next
)
1133 fprintf (f
, " [%d..%d]", r
->start
, r
->finish
);
1138 debug (lra_live_range
&ref
)
1140 lra_print_live_range_list (stderr
, &ref
);
1144 debug (lra_live_range
*ptr
)
1149 fprintf (stderr
, "<nil>\n");
1152 /* Print live ranges R to stderr. */
1154 lra_debug_live_range_list (lra_live_range_t r
)
1156 lra_print_live_range_list (stderr
, r
);
1159 /* Print live ranges of pseudo REGNO to file F. */
1161 print_pseudo_live_ranges (FILE *f
, int regno
)
1163 if (lra_reg_info
[regno
].live_ranges
== NULL
)
1165 fprintf (f
, " r%d:", regno
);
1166 lra_print_live_range_list (f
, lra_reg_info
[regno
].live_ranges
);
1169 /* Print live ranges of pseudo REGNO to stderr. */
1171 lra_debug_pseudo_live_ranges (int regno
)
1173 print_pseudo_live_ranges (stderr
, regno
);
1176 /* Print live ranges of all pseudos to file F. */
1178 print_live_ranges (FILE *f
)
1182 max_regno
= max_reg_num ();
1183 for (i
= FIRST_PSEUDO_REGISTER
; i
< max_regno
; i
++)
1184 print_pseudo_live_ranges (f
, i
);
1187 /* Print live ranges of all pseudos to stderr. */
1189 lra_debug_live_ranges (void)
1191 print_live_ranges (stderr
);
1194 /* Compress pseudo live ranges. */
1196 compress_live_ranges (void)
1198 remove_some_program_points_and_update_live_ranges ();
1199 if (lra_dump_file
!= NULL
)
1201 fprintf (lra_dump_file
, "Ranges after the compression:\n");
1202 print_live_ranges (lra_dump_file
);
1208 /* The number of the current live range pass. */
1209 int lra_live_range_iter
;
1211 /* The function creates live ranges only for memory pseudos (or for
1212 all ones if ALL_P), set up CONFLICT_HARD_REGS for the pseudos. It
1213 also does dead insn elimination if DEAD_INSN_P and global live
1214 analysis only for pseudos and only if the pseudo live info was
1215 changed on a BB border. Return TRUE if the live info was
1218 lra_create_live_ranges_1 (bool all_p
, bool dead_insn_p
)
1221 int i
, hard_regno
, max_regno
= max_reg_num ();
1223 bool bb_live_change_p
, have_referenced_pseudos
= false;
1225 timevar_push (TV_LRA_CREATE_LIVE_RANGES
);
1227 complete_info_p
= all_p
;
1228 if (lra_dump_file
!= NULL
)
1229 fprintf (lra_dump_file
,
1230 "\n********** Pseudo live ranges #%d: **********\n\n",
1231 ++lra_live_range_iter
);
1232 memset (lra_hard_reg_usage
, 0, sizeof (lra_hard_reg_usage
));
1233 for (i
= 0; i
< max_regno
; i
++)
1235 lra_reg_info
[i
].live_ranges
= NULL
;
1236 CLEAR_HARD_REG_SET (lra_reg_info
[i
].conflict_hard_regs
);
1237 lra_reg_info
[i
].preferred_hard_regno1
= -1;
1238 lra_reg_info
[i
].preferred_hard_regno2
= -1;
1239 lra_reg_info
[i
].preferred_hard_regno_profit1
= 0;
1240 lra_reg_info
[i
].preferred_hard_regno_profit2
= 0;
1242 lra_reg_info
[i
].no_stack_p
= false;
1244 /* The biggest mode is already set but its value might be to
1245 conservative because of recent transformation. Here in this
1246 file we recalculate it again as it costs practically
1248 if (regno_reg_rtx
[i
] != NULL_RTX
)
1249 lra_reg_info
[i
].biggest_mode
= GET_MODE (regno_reg_rtx
[i
]);
1251 lra_reg_info
[i
].biggest_mode
= VOIDmode
;
1252 #ifdef ENABLE_CHECKING
1253 lra_reg_info
[i
].call_p
= false;
1255 if (i
>= FIRST_PSEUDO_REGISTER
1256 && lra_reg_info
[i
].nrefs
!= 0)
1258 if ((hard_regno
= reg_renumber
[i
]) >= 0)
1259 lra_hard_reg_usage
[hard_regno
] += lra_reg_info
[i
].freq
;
1260 have_referenced_pseudos
= true;
1265 /* Under some circumstances, we can have functions without pseudo
1266 registers. For such functions, lra_live_max_point will be 0,
1267 see e.g. PR55604, and there's nothing more to do for us here. */
1268 if (! have_referenced_pseudos
)
1270 timevar_pop (TV_LRA_CREATE_LIVE_RANGES
);
1274 pseudos_live
= sparseset_alloc (max_regno
);
1275 pseudos_live_through_calls
= sparseset_alloc (max_regno
);
1276 pseudos_live_through_setjumps
= sparseset_alloc (max_regno
);
1277 start_living
= sparseset_alloc (max_regno
);
1278 start_dying
= sparseset_alloc (max_regno
);
1279 dead_set
= sparseset_alloc (max_regno
);
1280 unused_set
= sparseset_alloc (max_regno
);
1282 point_freq_vec
.create (get_max_uid () * 2);
1283 lra_point_freq
= point_freq_vec
.address ();
1284 int *post_order_rev_cfg
= XNEWVEC (int, last_basic_block_for_fn (cfun
));
1285 int n_blocks_inverted
= inverted_post_order_compute (post_order_rev_cfg
);
1286 lra_assert (n_blocks_inverted
== n_basic_blocks_for_fn (cfun
));
1287 bb_live_change_p
= false;
1288 for (i
= n_blocks_inverted
- 1; i
>= 0; --i
)
1290 bb
= BASIC_BLOCK_FOR_FN (cfun
, post_order_rev_cfg
[i
]);
1291 if (bb
== EXIT_BLOCK_PTR_FOR_FN (cfun
) || bb
1292 == ENTRY_BLOCK_PTR_FOR_FN (cfun
))
1294 if (process_bb_lives (bb
, curr_point
, dead_insn_p
))
1295 bb_live_change_p
= true;
1297 if (bb_live_change_p
)
1299 /* We need to clear pseudo live info as some pseudos can
1300 disappear, e.g. pseudos with used equivalences. */
1301 FOR_EACH_BB_FN (bb
, cfun
)
1303 bitmap_clear_range (df_get_live_in (bb
), FIRST_PSEUDO_REGISTER
,
1304 max_regno
- FIRST_PSEUDO_REGISTER
);
1305 bitmap_clear_range (df_get_live_out (bb
), FIRST_PSEUDO_REGISTER
,
1306 max_regno
- FIRST_PSEUDO_REGISTER
);
1308 /* As we did not change CFG since LRA start we can use
1309 DF-infrastructure solver to solve live data flow problem. */
1311 (DF_BACKWARD
, NULL
, live_con_fun_0
, live_con_fun_n
,
1312 live_trans_fun
, &all_blocks
,
1313 df_get_postorder (DF_BACKWARD
), df_get_n_blocks (DF_BACKWARD
));
1314 if (lra_dump_file
!= NULL
)
1316 fprintf (lra_dump_file
,
1317 "Global pseudo live data have been updated:\n");
1319 FOR_EACH_BB_FN (bb
, cfun
)
1321 bb_data_t bb_info
= get_bb_data (bb
);
1322 bitmap bb_livein
= df_get_live_in (bb
);
1323 bitmap bb_liveout
= df_get_live_out (bb
);
1325 fprintf (lra_dump_file
, "\nBB %d:\n", bb
->index
);
1326 lra_dump_bitmap_with_title (" gen:",
1327 &bb_info
->gen_pseudos
, bb
->index
);
1328 lra_dump_bitmap_with_title (" killed:",
1329 &bb_info
->killed_pseudos
, bb
->index
);
1330 lra_dump_bitmap_with_title (" livein:", bb_livein
, bb
->index
);
1331 lra_dump_bitmap_with_title (" liveout:", bb_liveout
, bb
->index
);
1335 free (post_order_rev_cfg
);
1336 lra_live_max_point
= curr_point
;
1337 if (lra_dump_file
!= NULL
)
1338 print_live_ranges (lra_dump_file
);
1340 sparseset_free (unused_set
);
1341 sparseset_free (dead_set
);
1342 sparseset_free (start_dying
);
1343 sparseset_free (start_living
);
1344 sparseset_free (pseudos_live_through_calls
);
1345 sparseset_free (pseudos_live_through_setjumps
);
1346 sparseset_free (pseudos_live
);
1347 compress_live_ranges ();
1348 timevar_pop (TV_LRA_CREATE_LIVE_RANGES
);
1349 return bb_live_change_p
;
1352 /* The main entry function creates live-ranges and other live info
1353 necessary for the assignment sub-pass. It uses
1354 lra_creates_live_ranges_1 -- so read comments for the
1357 lra_create_live_ranges (bool all_p
, bool dead_insn_p
)
1359 if (! lra_create_live_ranges_1 (all_p
, dead_insn_p
))
1361 if (lra_dump_file
!= NULL
)
1362 fprintf (lra_dump_file
, "Live info was changed -- recalculate it\n");
1363 /* Live info was changed on a bb border. It means that some info,
1364 e.g. about conflict regs, calls crossed, and live ranges may be
1365 wrong. We need this info for allocation. So recalculate it
1366 again but without removing dead insns which can change live info
1367 again. Repetitive live range calculations are expensive therefore
1368 we stop here as we already have correct info although some
1369 improvement in rare cases could be possible on this sub-pass if
1370 we do dead insn elimination again (still the improvement may
1372 lra_clear_live_ranges ();
1373 bool res
= lra_create_live_ranges_1 (all_p
, false);
1377 /* Finish all live ranges. */
1379 lra_clear_live_ranges (void)
1383 for (i
= 0; i
< max_reg_num (); i
++)
1384 free_live_range_list (lra_reg_info
[i
].live_ranges
);
1385 point_freq_vec
.release ();
1388 /* Initialize live ranges data once per function. */
1390 lra_live_ranges_init (void)
1392 live_range_pool
= create_alloc_pool ("live ranges",
1393 sizeof (struct lra_live_range
), 100);
1394 bitmap_initialize (&temp_bitmap
, ®_obstack
);
1395 initiate_live_solver ();
1398 /* Finish live ranges data once per function. */
1400 lra_live_ranges_finish (void)
1402 finish_live_solver ();
1403 bitmap_clear (&temp_bitmap
);
1404 free_alloc_pool (live_range_pool
);