diff options
Diffstat (limited to 'gcc/ira-lives.c')
| -rw-r--r-- | gcc/ira-lives.c | 390 |
1 files changed, 264 insertions, 126 deletions
diff --git a/gcc/ira-lives.c b/gcc/ira-lives.c index f879068aa5e..5b75f54e5d3 100644 --- a/gcc/ira-lives.c +++ b/gcc/ira-lives.c @@ -33,6 +33,7 @@ along with GCC; see the file COPYING3. If not see #include "basic-block.h" #include "insn-config.h" #include "recog.h" +#include "diagnostic-core.h" #include "toplev.h" #include "params.h" #include "df.h" @@ -67,8 +68,12 @@ static int curr_point; classes. */ static int high_pressure_start_point[N_REG_CLASSES]; -/* Allocnos live at current point in the scan. */ -static sparseset allocnos_live; +/* Objects live at current point in the scan. */ +static sparseset objects_live; + +/* A temporary bitmap used in functions that wish to avoid visiting an allocno + multiple times. */ +static sparseset allocnos_processed; /* Set of hard regs (except eliminable ones) currently live. */ static HARD_REG_SET hard_regs_live; @@ -81,20 +86,19 @@ static int last_call_num; /* The number of last call at which given allocno was saved. */ static int *allocno_saved_at_call; -/* Record the birth of hard register REGNO, updating hard_regs_live - and hard reg conflict information for living allocno. */ +/* Record the birth of hard register REGNO, updating hard_regs_live and + hard reg conflict information for living allocnos. */ static void make_hard_regno_born (int regno) { unsigned int i; SET_HARD_REG_BIT (hard_regs_live, regno); - EXECUTE_IF_SET_IN_SPARSESET (allocnos_live, i) + EXECUTE_IF_SET_IN_SPARSESET (objects_live, i) { - SET_HARD_REG_BIT (ALLOCNO_CONFLICT_HARD_REGS (ira_allocnos[i]), - regno); - SET_HARD_REG_BIT (ALLOCNO_TOTAL_CONFLICT_HARD_REGS (ira_allocnos[i]), - regno); + ira_object_t obj = ira_object_id_map[i]; + SET_HARD_REG_BIT (OBJECT_CONFLICT_HARD_REGS (obj), regno); + SET_HARD_REG_BIT (OBJECT_TOTAL_CONFLICT_HARD_REGS (obj), regno); } } @@ -106,29 +110,29 @@ make_hard_regno_dead (int regno) CLEAR_HARD_REG_BIT (hard_regs_live, regno); } -/* Record the birth of allocno A, starting a new live range for - it if necessary, and updating hard reg conflict information. We also - record it in allocnos_live. */ +/* Record the birth of object OBJ. Set a bit for it in objects_live, + start a new live range for it if necessary and update hard register + conflicts. */ static void -make_allocno_born (ira_allocno_t a) +make_object_born (ira_object_t obj) { - live_range_t p = ALLOCNO_LIVE_RANGES (a); + live_range_t lr = OBJECT_LIVE_RANGES (obj); - sparseset_set_bit (allocnos_live, ALLOCNO_NUM (a)); - IOR_HARD_REG_SET (ALLOCNO_CONFLICT_HARD_REGS (a), hard_regs_live); - IOR_HARD_REG_SET (ALLOCNO_TOTAL_CONFLICT_HARD_REGS (a), hard_regs_live); + sparseset_set_bit (objects_live, OBJECT_CONFLICT_ID (obj)); + IOR_HARD_REG_SET (OBJECT_CONFLICT_HARD_REGS (obj), hard_regs_live); + IOR_HARD_REG_SET (OBJECT_TOTAL_CONFLICT_HARD_REGS (obj), hard_regs_live); - if (p == NULL - || (p->finish != curr_point && p->finish + 1 != curr_point)) - ALLOCNO_LIVE_RANGES (a) - = ira_create_allocno_live_range (a, curr_point, -1, - ALLOCNO_LIVE_RANGES (a)); + if (lr == NULL + || (lr->finish != curr_point && lr->finish + 1 != curr_point)) + ira_add_live_range_to_object (obj, curr_point, -1); } -/* Update ALLOCNO_EXCESS_PRESSURE_POINTS_NUM for allocno A. */ +/* Update ALLOCNO_EXCESS_PRESSURE_POINTS_NUM for the allocno + associated with object OBJ. */ static void -update_allocno_pressure_excess_length (ira_allocno_t a) +update_allocno_pressure_excess_length (ira_object_t obj) { + ira_allocno_t a = OBJECT_ALLOCNO (obj); int start, i; enum reg_class cover_class, cl; live_range_t p; @@ -140,7 +144,7 @@ update_allocno_pressure_excess_length (ira_allocno_t a) { if (high_pressure_start_point[cl] < 0) continue; - p = ALLOCNO_LIVE_RANGES (a); + p = OBJECT_LIVE_RANGES (obj); ira_assert (p != NULL); start = (high_pressure_start_point[cl] > p->start ? high_pressure_start_point[cl] : p->start); @@ -148,18 +152,18 @@ update_allocno_pressure_excess_length (ira_allocno_t a) } } -/* Process the death of allocno A. This finishes the current live - range for it. */ +/* Process the death of object OBJ, which is associated with allocno + A. This finishes the current live range for it. */ static void -make_allocno_dead (ira_allocno_t a) +make_object_dead (ira_object_t obj) { - live_range_t p; + live_range_t lr; - p = ALLOCNO_LIVE_RANGES (a); - ira_assert (p != NULL); - p->finish = curr_point; - update_allocno_pressure_excess_length (a); - sparseset_clear_bit (allocnos_live, ALLOCNO_NUM (a)); + sparseset_clear_bit (objects_live, OBJECT_CONFLICT_ID (obj)); + lr = OBJECT_LIVE_RANGES (obj); + ira_assert (lr != NULL); + lr->finish = curr_point; + update_allocno_pressure_excess_length (obj); } /* The current register pressures for each cover class for the current @@ -214,8 +218,8 @@ dec_register_pressure (enum reg_class cover_class, int nregs) } if (set_p) { - EXECUTE_IF_SET_IN_SPARSESET (allocnos_live, j) - update_allocno_pressure_excess_length (ira_allocnos[j]); + EXECUTE_IF_SET_IN_SPARSESET (objects_live, j) + update_allocno_pressure_excess_length (ira_object_id_map[j]); for (i = 0; (cl = ira_reg_class_super_classes[cover_class][i]) != LIM_REG_CLASSES; @@ -232,8 +236,8 @@ static void mark_pseudo_regno_live (int regno) { ira_allocno_t a = ira_curr_regno_allocno_map[regno]; + int i, n, nregs; enum reg_class cl; - int nregs; if (a == NULL) return; @@ -241,18 +245,66 @@ mark_pseudo_regno_live (int regno) /* Invalidate because it is referenced. */ allocno_saved_at_call[ALLOCNO_NUM (a)] = 0; - if (sparseset_bit_p (allocnos_live, ALLOCNO_NUM (a))) + n = ALLOCNO_NUM_OBJECTS (a); + cl = ALLOCNO_COVER_CLASS (a); + nregs = ira_reg_class_nregs[cl][ALLOCNO_MODE (a)]; + if (n > 1) + { + /* We track every subobject separately. */ + gcc_assert (nregs == n); + nregs = 1; + } + + for (i = 0; i < n; i++) + { + ira_object_t obj = ALLOCNO_OBJECT (a, i); + if (sparseset_bit_p (objects_live, OBJECT_CONFLICT_ID (obj))) + continue; + + inc_register_pressure (cl, nregs); + make_object_born (obj); + } +} + +/* Like mark_pseudo_regno_live, but try to only mark one subword of + the pseudo as live. SUBWORD indicates which; a value of 0 + indicates the low part. */ +static void +mark_pseudo_regno_subword_live (int regno, int subword) +{ + ira_allocno_t a = ira_curr_regno_allocno_map[regno]; + int n, nregs; + enum reg_class cl; + ira_object_t obj; + + if (a == NULL) return; + /* Invalidate because it is referenced. */ + allocno_saved_at_call[ALLOCNO_NUM (a)] = 0; + + n = ALLOCNO_NUM_OBJECTS (a); + if (n == 1) + { + mark_pseudo_regno_live (regno); + return; + } + cl = ALLOCNO_COVER_CLASS (a); nregs = ira_reg_class_nregs[cl][ALLOCNO_MODE (a)]; + gcc_assert (nregs == n); + obj = ALLOCNO_OBJECT (a, subword); + + if (sparseset_bit_p (objects_live, OBJECT_CONFLICT_ID (obj))) + return; + inc_register_pressure (cl, nregs); - make_allocno_born (a); + make_object_born (obj); } -/* Mark the hard register REG as live. Store a 1 in hard_regs_live - for this register, record how many consecutive hardware registers - it actually needs. */ +/* Mark the register REG as live. Store a 1 in hard_regs_live for + this register, record how many consecutive hardware registers it + actually needs. */ static void mark_hard_reg_live (rtx reg) { @@ -280,13 +332,22 @@ mark_hard_reg_live (rtx reg) static void mark_ref_live (df_ref ref) { - rtx reg; + rtx reg = DF_REF_REG (ref); + rtx orig_reg = reg; - reg = DF_REF_REG (ref); if (GET_CODE (reg) == SUBREG) reg = SUBREG_REG (reg); + if (REGNO (reg) >= FIRST_PSEUDO_REGISTER) - mark_pseudo_regno_live (REGNO (reg)); + { + if (df_read_modify_subreg_p (orig_reg)) + { + mark_pseudo_regno_subword_live (REGNO (reg), + subreg_lowpart_p (orig_reg) ? 0 : 1); + } + else + mark_pseudo_regno_live (REGNO (reg)); + } else mark_hard_reg_live (reg); } @@ -297,8 +358,44 @@ static void mark_pseudo_regno_dead (int regno) { ira_allocno_t a = ira_curr_regno_allocno_map[regno]; + int n, i, nregs; + enum reg_class cl; + + if (a == NULL) + return; + + /* Invalidate because it is referenced. */ + allocno_saved_at_call[ALLOCNO_NUM (a)] = 0; + + n = ALLOCNO_NUM_OBJECTS (a); + cl = ALLOCNO_COVER_CLASS (a); + nregs = ira_reg_class_nregs[cl][ALLOCNO_MODE (a)]; + if (n > 1) + { + /* We track every subobject separately. */ + gcc_assert (nregs == n); + nregs = 1; + } + for (i = 0; i < n; i++) + { + ira_object_t obj = ALLOCNO_OBJECT (a, i); + if (!sparseset_bit_p (objects_live, OBJECT_CONFLICT_ID (obj))) + continue; + + dec_register_pressure (cl, nregs); + make_object_dead (obj); + } +} + +/* Like mark_pseudo_regno_dead, but called when we know that only part of the + register dies. SUBWORD indicates which; a value of 0 indicates the low part. */ +static void +mark_pseudo_regno_subword_dead (int regno, int subword) +{ + ira_allocno_t a = ira_curr_regno_allocno_map[regno]; + int n, nregs; enum reg_class cl; - int nregs; + ira_object_t obj; if (a == NULL) return; @@ -306,18 +403,25 @@ mark_pseudo_regno_dead (int regno) /* Invalidate because it is referenced. */ allocno_saved_at_call[ALLOCNO_NUM (a)] = 0; - if (! sparseset_bit_p (allocnos_live, ALLOCNO_NUM (a))) + n = ALLOCNO_NUM_OBJECTS (a); + if (n == 1) + /* The allocno as a whole doesn't die in this case. */ return; cl = ALLOCNO_COVER_CLASS (a); nregs = ira_reg_class_nregs[cl][ALLOCNO_MODE (a)]; - dec_register_pressure (cl, nregs); + gcc_assert (nregs == n); + + obj = ALLOCNO_OBJECT (a, subword); + if (!sparseset_bit_p (objects_live, OBJECT_CONFLICT_ID (obj))) + return; - make_allocno_dead (a); + dec_register_pressure (cl, 1); + make_object_dead (obj); } -/* Mark the hard register REG as dead. Store a 0 in hard_regs_live - for the register. */ +/* Mark the hard register REG as dead. Store a 0 in hard_regs_live for the + register. */ static void mark_hard_reg_dead (rtx reg) { @@ -345,17 +449,31 @@ mark_hard_reg_dead (rtx reg) static void mark_ref_dead (df_ref def) { - rtx reg; + rtx reg = DF_REF_REG (def); + rtx orig_reg = reg; - if (DF_REF_FLAGS_IS_SET (def, DF_REF_PARTIAL) - || DF_REF_FLAGS_IS_SET (def, DF_REF_CONDITIONAL)) + if (DF_REF_FLAGS_IS_SET (def, DF_REF_CONDITIONAL)) return; - reg = DF_REF_REG (def); if (GET_CODE (reg) == SUBREG) reg = SUBREG_REG (reg); + + if (DF_REF_FLAGS_IS_SET (def, DF_REF_PARTIAL) + && (GET_CODE (orig_reg) != SUBREG + || REGNO (reg) < FIRST_PSEUDO_REGISTER + || !df_read_modify_subreg_p (orig_reg))) + return; + if (REGNO (reg) >= FIRST_PSEUDO_REGISTER) - mark_pseudo_regno_dead (REGNO (reg)); + { + if (df_read_modify_subreg_p (orig_reg)) + { + mark_pseudo_regno_subword_dead (REGNO (reg), + subreg_lowpart_p (orig_reg) ? 0 : 1); + } + else + mark_pseudo_regno_dead (REGNO (reg)); + } else mark_hard_reg_dead (reg); } @@ -466,7 +584,7 @@ check_and_make_def_conflict (int alt, int def, enum reg_class def_cl) /* If there's any alternative that allows USE to match DEF, do not record a conflict. If that causes us to create an invalid - instruction due to the earlyclobber, reload must fix it up. */ + instruction due to the earlyclobber, reload must fix it up. */ for (alt1 = 0; alt1 < recog_data.n_alternatives; alt1++) if (recog_op_alt[use][alt1].matches == def || (use < recog_data.n_operands - 1 @@ -834,17 +952,18 @@ process_single_reg_class_operands (bool in_p, int freq) } } - EXECUTE_IF_SET_IN_SPARSESET (allocnos_live, px) + EXECUTE_IF_SET_IN_SPARSESET (objects_live, px) { - a = ira_allocnos[px]; + ira_object_t obj = ira_object_id_map[px]; + a = OBJECT_ALLOCNO (obj); if (a != operand_a) { /* We could increase costs of A instead of making it conflicting with the hard register. But it works worse because it will be spilled in reload in anyway. */ - IOR_HARD_REG_SET (ALLOCNO_CONFLICT_HARD_REGS (a), + IOR_HARD_REG_SET (OBJECT_CONFLICT_HARD_REGS (obj), reg_class_contents[cl]); - IOR_HARD_REG_SET (ALLOCNO_TOTAL_CONFLICT_HARD_REGS (a), + IOR_HARD_REG_SET (OBJECT_TOTAL_CONFLICT_HARD_REGS (obj), reg_class_contents[cl]); } } @@ -893,7 +1012,7 @@ process_bb_node_lives (ira_loop_tree_node_t loop_tree_node) } curr_bb_node = loop_tree_node; reg_live_out = DF_LR_OUT (bb); - sparseset_clear (allocnos_live); + sparseset_clear (objects_live); REG_SET_TO_HARD_REG_SET (hard_regs_live, reg_live_out); AND_COMPL_HARD_REG_SET (hard_regs_live, eliminable_regset); AND_COMPL_HARD_REG_SET (hard_regs_live, ira_no_alloc_regs); @@ -1007,21 +1126,14 @@ process_bb_node_lives (ira_loop_tree_node_t loop_tree_node) if (call_p) { last_call_num++; + sparseset_clear (allocnos_processed); /* The current set of live allocnos are live across the call. */ - EXECUTE_IF_SET_IN_SPARSESET (allocnos_live, i) + EXECUTE_IF_SET_IN_SPARSESET (objects_live, i) { - ira_allocno_t a = ira_allocnos[i]; + ira_object_t obj = ira_object_id_map[i]; + ira_allocno_t a = OBJECT_ALLOCNO (obj); + int num = ALLOCNO_NUM (a); - if (allocno_saved_at_call[i] != last_call_num) - /* Here we are mimicking caller-save.c behaviour - which does not save hard register at a call if - it was saved on previous call in the same basic - block and the hard register was not mentioned - between the two calls. */ - ALLOCNO_CALL_FREQ (a) += freq; - /* Mark it as saved at the next call. */ - allocno_saved_at_call[i] = last_call_num + 1; - ALLOCNO_CALLS_CROSSED_NUM (a)++; /* Don't allocate allocnos that cross setjmps or any call, if this function receives a nonlocal goto. */ @@ -1029,16 +1141,31 @@ process_bb_node_lives (ira_loop_tree_node_t loop_tree_node) || find_reg_note (insn, REG_SETJMP, NULL_RTX) != NULL_RTX) { - SET_HARD_REG_SET (ALLOCNO_CONFLICT_HARD_REGS (a)); - SET_HARD_REG_SET (ALLOCNO_TOTAL_CONFLICT_HARD_REGS (a)); + SET_HARD_REG_SET (OBJECT_CONFLICT_HARD_REGS (obj)); + SET_HARD_REG_SET (OBJECT_TOTAL_CONFLICT_HARD_REGS (obj)); } if (can_throw_internal (insn)) { - IOR_HARD_REG_SET (ALLOCNO_TOTAL_CONFLICT_HARD_REGS (a), + IOR_HARD_REG_SET (OBJECT_CONFLICT_HARD_REGS (obj), call_used_reg_set); - IOR_HARD_REG_SET (ALLOCNO_CONFLICT_HARD_REGS (a), + IOR_HARD_REG_SET (OBJECT_TOTAL_CONFLICT_HARD_REGS (obj), call_used_reg_set); } + + if (sparseset_bit_p (allocnos_processed, num)) + continue; + sparseset_set_bit (allocnos_processed, num); + + if (allocno_saved_at_call[num] != last_call_num) + /* Here we are mimicking caller-save.c behaviour + which does not save hard register at a call if + it was saved on previous call in the same basic + block and the hard register was not mentioned + between the two calls. */ + ALLOCNO_CALL_FREQ (a) += freq; + /* Mark it as saved at the next call. */ + allocno_saved_at_call[num] = last_call_num + 1; + ALLOCNO_CALLS_CROSSED_NUM (a)++; } } @@ -1096,10 +1223,11 @@ process_bb_node_lives (ira_loop_tree_node_t loop_tree_node) if (bb_has_abnormal_pred (bb)) { #ifdef STACK_REGS - EXECUTE_IF_SET_IN_SPARSESET (allocnos_live, px) + EXECUTE_IF_SET_IN_SPARSESET (objects_live, px) { - ALLOCNO_NO_STACK_REG_P (ira_allocnos[px]) = true; - ALLOCNO_TOTAL_NO_STACK_REG_P (ira_allocnos[px]) = true; + ira_allocno_t a = OBJECT_ALLOCNO (ira_object_id_map[px]); + ALLOCNO_NO_STACK_REG_P (a) = true; + ALLOCNO_TOTAL_NO_STACK_REG_P (a) = true; } for (px = FIRST_STACK_REG; px <= LAST_STACK_REG; px++) make_hard_regno_born (px); @@ -1113,8 +1241,8 @@ process_bb_node_lives (ira_loop_tree_node_t loop_tree_node) make_hard_regno_born (px); } - EXECUTE_IF_SET_IN_SPARSESET (allocnos_live, i) - make_allocno_dead (ira_allocnos[i]); + EXECUTE_IF_SET_IN_SPARSESET (objects_live, i) + make_object_dead (ira_object_id_map[i]); curr_point++; @@ -1138,30 +1266,24 @@ process_bb_node_lives (ira_loop_tree_node_t loop_tree_node) static void create_start_finish_chains (void) { - ira_allocno_t a; - ira_allocno_iterator ai; + ira_object_t obj; + ira_object_iterator oi; live_range_t r; ira_start_point_ranges - = (live_range_t *) ira_allocate (ira_max_point - * sizeof (live_range_t)); - memset (ira_start_point_ranges, 0, - ira_max_point * sizeof (live_range_t)); + = (live_range_t *) ira_allocate (ira_max_point * sizeof (live_range_t)); + memset (ira_start_point_ranges, 0, ira_max_point * sizeof (live_range_t)); ira_finish_point_ranges - = (live_range_t *) ira_allocate (ira_max_point - * sizeof (live_range_t)); - memset (ira_finish_point_ranges, 0, - ira_max_point * sizeof (live_range_t)); - FOR_EACH_ALLOCNO (a, ai) - { - for (r = ALLOCNO_LIVE_RANGES (a); r != NULL; r = r->next) - { - r->start_next = ira_start_point_ranges[r->start]; - ira_start_point_ranges[r->start] = r; - r->finish_next = ira_finish_point_ranges[r->finish]; + = (live_range_t *) ira_allocate (ira_max_point * sizeof (live_range_t)); + memset (ira_finish_point_ranges, 0, ira_max_point * sizeof (live_range_t)); + FOR_EACH_OBJECT (obj, oi) + for (r = OBJECT_LIVE_RANGES (obj); r != NULL; r = r->next) + { + r->start_next = ira_start_point_ranges[r->start]; + ira_start_point_ranges[r->start] = r; + r->finish_next = ira_finish_point_ranges[r->finish]; ira_finish_point_ranges[r->finish] = r; - } - } + } } /* Rebuild IRA_START_POINT_RANGES and IRA_FINISH_POINT_RANGES after @@ -1183,22 +1305,21 @@ remove_some_program_points_and_update_live_ranges (void) unsigned i; int n; int *map; - ira_allocno_t a; - ira_allocno_iterator ai; + ira_object_t obj; + ira_object_iterator oi; live_range_t r; bitmap born_or_died; bitmap_iterator bi; born_or_died = ira_allocate_bitmap (); - FOR_EACH_ALLOCNO (a, ai) - { - for (r = ALLOCNO_LIVE_RANGES (a); r != NULL; r = r->next) - { - ira_assert (r->start <= r->finish); - bitmap_set_bit (born_or_died, r->start); - bitmap_set_bit (born_or_died, r->finish); - } - } + FOR_EACH_OBJECT (obj, oi) + for (r = OBJECT_LIVE_RANGES (obj); r != NULL; r = r->next) + { + ira_assert (r->start <= r->finish); + bitmap_set_bit (born_or_died, r->start); + bitmap_set_bit (born_or_died, r->finish); + } + map = (int *) ira_allocate (sizeof (int) * ira_max_point); n = 0; EXECUTE_IF_SET_IN_BITMAP(born_or_died, 0, i, bi) @@ -1210,14 +1331,14 @@ remove_some_program_points_and_update_live_ranges (void) fprintf (ira_dump_file, "Compressing live ranges: from %d to %d - %d%%\n", ira_max_point, n, 100 * n / ira_max_point); ira_max_point = n; - FOR_EACH_ALLOCNO (a, ai) - { - for (r = ALLOCNO_LIVE_RANGES (a); r != NULL; r = r->next) - { - r->start = map[r->start]; - r->finish = map[r->finish]; - } - } + + FOR_EACH_OBJECT (obj, oi) + for (r = OBJECT_LIVE_RANGES (obj); r != NULL; r = r->next) + { + r->start = map[r->start]; + r->finish = map[r->finish]; + } + ira_free (map); } @@ -1237,12 +1358,27 @@ ira_debug_live_range_list (live_range_t r) ira_print_live_range_list (stderr, r); } +/* Print live ranges of object OBJ to file F. */ +static void +print_object_live_ranges (FILE *f, ira_object_t obj) +{ + ira_print_live_range_list (f, OBJECT_LIVE_RANGES (obj)); +} + /* Print live ranges of allocno A to file F. */ static void print_allocno_live_ranges (FILE *f, ira_allocno_t a) { - fprintf (f, " a%d(r%d):", ALLOCNO_NUM (a), ALLOCNO_REGNO (a)); - ira_print_live_range_list (f, ALLOCNO_LIVE_RANGES (a)); + int n = ALLOCNO_NUM_OBJECTS (a); + int i; + for (i = 0; i < n; i++) + { + fprintf (f, " a%d(r%d", ALLOCNO_NUM (a), ALLOCNO_REGNO (a)); + if (n > 1) + fprintf (f, " [%d]", i); + fprintf (f, "):"); + print_object_live_ranges (f, ALLOCNO_OBJECT (a, i)); + } } /* Print live ranges of allocno A to stderr. */ @@ -1271,12 +1407,13 @@ ira_debug_live_ranges (void) } /* The main entry function creates live ranges, set up - CONFLICT_HARD_REGS and TOTAL_CONFLICT_HARD_REGS for allocnos, and + CONFLICT_HARD_REGS and TOTAL_CONFLICT_HARD_REGS for objects, and calculate register pressure info. */ void ira_create_allocno_live_ranges (void) { - allocnos_live = sparseset_alloc (ira_allocnos_num); + objects_live = sparseset_alloc (ira_objects_num); + allocnos_processed = sparseset_alloc (ira_allocnos_num); curr_point = 0; last_call_num = 0; allocno_saved_at_call @@ -1290,7 +1427,8 @@ ira_create_allocno_live_ranges (void) print_live_ranges (ira_dump_file); /* Clean up. */ ira_free (allocno_saved_at_call); - sparseset_free (allocnos_live); + sparseset_free (objects_live); + sparseset_free (allocnos_processed); } /* Compress allocno live ranges. */ |