diff options
Diffstat (limited to 'gcc/ira-build.c')
| -rw-r--r-- | gcc/ira-build.c | 349 |
1 files changed, 188 insertions, 161 deletions
diff --git a/gcc/ira-build.c b/gcc/ira-build.c index b3c1e14f8f7..f7cb36e8766 100644 --- a/gcc/ira-build.c +++ b/gcc/ira-build.c @@ -415,7 +415,8 @@ initiate_allocnos (void) = VEC_alloc (ira_object_t, heap, max_reg_num () * 2); ira_object_id_map = NULL; ira_regno_allocno_map - = (ira_allocno_t *) ira_allocate (max_reg_num () * sizeof (ira_allocno_t)); + = (ira_allocno_t *) ira_allocate (max_reg_num () + * sizeof (ira_allocno_t)); memset (ira_regno_allocno_map, 0, max_reg_num () * sizeof (ira_allocno_t)); } @@ -423,7 +424,7 @@ initiate_allocnos (void) static ira_object_t ira_create_object (ira_allocno_t a, int subword) { - enum reg_class cover_class = ALLOCNO_COVER_CLASS (a); + enum reg_class aclass = ALLOCNO_CLASS (a); ira_object_t obj = (ira_object_t) pool_alloc (object_pool); OBJECT_ALLOCNO (obj) = a; @@ -435,12 +436,13 @@ ira_create_object (ira_allocno_t a, int subword) COPY_HARD_REG_SET (OBJECT_CONFLICT_HARD_REGS (obj), ira_no_alloc_regs); COPY_HARD_REG_SET (OBJECT_TOTAL_CONFLICT_HARD_REGS (obj), ira_no_alloc_regs); IOR_COMPL_HARD_REG_SET (OBJECT_CONFLICT_HARD_REGS (obj), - reg_class_contents[cover_class]); + reg_class_contents[aclass]); IOR_COMPL_HARD_REG_SET (OBJECT_TOTAL_CONFLICT_HARD_REGS (obj), - reg_class_contents[cover_class]); + reg_class_contents[aclass]); OBJECT_MIN (obj) = INT_MAX; OBJECT_MAX (obj) = -1; OBJECT_LIVE_RANGES (obj) = NULL; + OBJECT_ADD_DATA (obj) = NULL; VEC_safe_push (ira_object_t, heap, ira_object_id_map_vec, obj); ira_object_id_map @@ -454,7 +456,8 @@ ira_create_object (ira_allocno_t a, int subword) LOOP_TREE_NODE. Add the allocno to the list of allocnos with the same regno if CAP_P is FALSE. */ ira_allocno_t -ira_create_allocno (int regno, bool cap_p, ira_loop_tree_node_t loop_tree_node) +ira_create_allocno (int regno, bool cap_p, + ira_loop_tree_node_t loop_tree_node) { ira_allocno_t a; @@ -484,35 +487,24 @@ ira_create_allocno (int regno, bool cap_p, ira_loop_tree_node_t loop_tree_node) ALLOCNO_NO_STACK_REG_P (a) = false; ALLOCNO_TOTAL_NO_STACK_REG_P (a) = false; #endif - ALLOCNO_MEM_OPTIMIZED_DEST (a) = NULL; - ALLOCNO_MEM_OPTIMIZED_DEST_P (a) = false; - ALLOCNO_SOMEWHERE_RENAMED_P (a) = false; - ALLOCNO_CHILD_RENAMED_P (a) = false; ALLOCNO_DONT_REASSIGN_P (a) = false; ALLOCNO_BAD_SPILL_P (a) = false; - ALLOCNO_IN_GRAPH_P (a) = false; ALLOCNO_ASSIGNED_P (a) = false; - ALLOCNO_MAY_BE_SPILLED_P (a) = false; - ALLOCNO_SPLAY_REMOVED_P (a) = false; ALLOCNO_MODE (a) = (regno < 0 ? VOIDmode : PSEUDO_REGNO_MODE (regno)); ALLOCNO_COPIES (a) = NULL; ALLOCNO_HARD_REG_COSTS (a) = NULL; ALLOCNO_CONFLICT_HARD_REG_COSTS (a) = NULL; ALLOCNO_UPDATED_HARD_REG_COSTS (a) = NULL; ALLOCNO_UPDATED_CONFLICT_HARD_REG_COSTS (a) = NULL; - ALLOCNO_LEFT_CONFLICTS_SIZE (a) = -1; - ALLOCNO_COVER_CLASS (a) = NO_REGS; - ALLOCNO_UPDATED_COVER_CLASS_COST (a) = 0; - ALLOCNO_COVER_CLASS_COST (a) = 0; + ALLOCNO_CLASS (a) = NO_REGS; + ALLOCNO_UPDATED_CLASS_COST (a) = 0; + ALLOCNO_CLASS_COST (a) = 0; ALLOCNO_MEMORY_COST (a) = 0; ALLOCNO_UPDATED_MEMORY_COST (a) = 0; ALLOCNO_EXCESS_PRESSURE_POINTS_NUM (a) = 0; - ALLOCNO_NEXT_BUCKET_ALLOCNO (a) = NULL; - ALLOCNO_PREV_BUCKET_ALLOCNO (a) = NULL; - ALLOCNO_FIRST_COALESCED_ALLOCNO (a) = a; - ALLOCNO_NEXT_COALESCED_ALLOCNO (a) = a; ALLOCNO_NUM_OBJECTS (a) = 0; + ALLOCNO_ADD_DATA (a) = NULL; VEC_safe_push (ira_allocno_t, heap, allocno_vec, a); ira_allocnos = VEC_address (ira_allocno_t, allocno_vec); ira_allocnos_num = VEC_length (ira_allocno_t, allocno_vec); @@ -520,11 +512,22 @@ ira_create_allocno (int regno, bool cap_p, ira_loop_tree_node_t loop_tree_node) return a; } -/* Set up cover class for A and update its conflict hard registers. */ +/* Set up register class for A and update its conflict hard + registers. */ void -ira_set_allocno_cover_class (ira_allocno_t a, enum reg_class cover_class) +ira_set_allocno_class (ira_allocno_t a, enum reg_class aclass) { - ALLOCNO_COVER_CLASS (a) = cover_class; + ira_allocno_object_iterator oi; + ira_object_t obj; + + ALLOCNO_CLASS (a) = aclass; + FOR_EACH_ALLOCNO_OBJECT (a, obj, oi) + { + IOR_COMPL_HARD_REG_SET (OBJECT_CONFLICT_HARD_REGS (obj), + reg_class_contents[aclass]); + IOR_COMPL_HARD_REG_SET (OBJECT_TOTAL_CONFLICT_HARD_REGS (obj), + reg_class_contents[aclass]); + } } /* Determine the number of objects we should associate with allocno A @@ -533,8 +536,8 @@ void ira_create_allocno_objects (ira_allocno_t a) { enum machine_mode mode = ALLOCNO_MODE (a); - enum reg_class cover_class = ALLOCNO_COVER_CLASS (a); - int n = ira_reg_class_nregs[cover_class][mode]; + enum reg_class aclass = ALLOCNO_CLASS (a); + int n = ira_reg_class_max_nregs[aclass][mode]; int i; if (GET_MODE_SIZE (mode) != 2 * UNITS_PER_WORD || n != 2) @@ -546,7 +549,7 @@ ira_create_allocno_objects (ira_allocno_t a) } /* For each allocno, set ALLOCNO_NUM_OBJECTS and create the - ALLOCNO_OBJECT structures. This must be called after the cover + ALLOCNO_OBJECT structures. This must be called after the allocno classes are known. */ static void create_allocno_objects (void) @@ -571,6 +574,7 @@ merge_hard_reg_conflicts (ira_allocno_t from, ira_allocno_t to, { ira_object_t from_obj = ALLOCNO_OBJECT (from, i); ira_object_t to_obj = ALLOCNO_OBJECT (to, i); + if (!total_only) IOR_HARD_REG_SET (OBJECT_CONFLICT_HARD_REGS (to_obj), OBJECT_CONFLICT_HARD_REGS (from_obj)); @@ -592,6 +596,7 @@ ior_hard_reg_conflicts (ira_allocno_t a, HARD_REG_SET *set) { ira_allocno_object_iterator i; ira_object_t obj; + FOR_EACH_ALLOCNO_OBJECT (a, obj, i) { IOR_HARD_REG_SET (OBJECT_CONFLICT_HARD_REGS (obj), *set); @@ -849,25 +854,22 @@ create_cap_allocno (ira_allocno_t a) { ira_allocno_t cap; ira_loop_tree_node_t parent; - enum reg_class cover_class; + enum reg_class aclass; - ira_assert (ALLOCNO_FIRST_COALESCED_ALLOCNO (a) == a - && ALLOCNO_NEXT_COALESCED_ALLOCNO (a) == a); parent = ALLOCNO_LOOP_TREE_NODE (a)->parent; cap = ira_create_allocno (ALLOCNO_REGNO (a), true, parent); ALLOCNO_MODE (cap) = ALLOCNO_MODE (a); - cover_class = ALLOCNO_COVER_CLASS (a); - ira_set_allocno_cover_class (cap, cover_class); + aclass = ALLOCNO_CLASS (a); + ira_set_allocno_class (cap, aclass); ira_create_allocno_objects (cap); - ALLOCNO_AVAILABLE_REGS_NUM (cap) = ALLOCNO_AVAILABLE_REGS_NUM (a); ALLOCNO_CAP_MEMBER (cap) = a; ALLOCNO_CAP (a) = cap; - ALLOCNO_COVER_CLASS_COST (cap) = ALLOCNO_COVER_CLASS_COST (a); + ALLOCNO_CLASS_COST (cap) = ALLOCNO_CLASS_COST (a); ALLOCNO_MEMORY_COST (cap) = ALLOCNO_MEMORY_COST (a); ira_allocate_and_copy_costs - (&ALLOCNO_HARD_REG_COSTS (cap), cover_class, ALLOCNO_HARD_REG_COSTS (a)); + (&ALLOCNO_HARD_REG_COSTS (cap), aclass, ALLOCNO_HARD_REG_COSTS (a)); ira_allocate_and_copy_costs - (&ALLOCNO_CONFLICT_HARD_REG_COSTS (cap), cover_class, + (&ALLOCNO_CONFLICT_HARD_REG_COSTS (cap), aclass, ALLOCNO_CONFLICT_HARD_REG_COSTS (a)); ALLOCNO_BAD_SPILL_P (cap) = ALLOCNO_BAD_SPILL_P (a); ALLOCNO_NREFS (cap) = ALLOCNO_NREFS (a); @@ -1063,23 +1065,24 @@ ira_finish_live_range_list (live_range_t r) void ira_free_allocno_updated_costs (ira_allocno_t a) { - enum reg_class cover_class; + enum reg_class aclass; - cover_class = ALLOCNO_COVER_CLASS (a); + aclass = ALLOCNO_CLASS (a); if (ALLOCNO_UPDATED_HARD_REG_COSTS (a) != NULL) - ira_free_cost_vector (ALLOCNO_UPDATED_HARD_REG_COSTS (a), cover_class); + ira_free_cost_vector (ALLOCNO_UPDATED_HARD_REG_COSTS (a), aclass); ALLOCNO_UPDATED_HARD_REG_COSTS (a) = NULL; if (ALLOCNO_UPDATED_CONFLICT_HARD_REG_COSTS (a) != NULL) ira_free_cost_vector (ALLOCNO_UPDATED_CONFLICT_HARD_REG_COSTS (a), - cover_class); + aclass); ALLOCNO_UPDATED_CONFLICT_HARD_REG_COSTS (a) = NULL; } -/* Free the memory allocated for allocno A. */ +/* Free and nullify all cost vectors allocated earlier for allocno + A. */ static void -finish_allocno (ira_allocno_t a) +ira_free_allocno_costs (ira_allocno_t a) { - enum reg_class cover_class = ALLOCNO_COVER_CLASS (a); + enum reg_class aclass = ALLOCNO_CLASS (a); ira_object_t obj; ira_allocno_object_iterator oi; @@ -1094,14 +1097,25 @@ finish_allocno (ira_allocno_t a) ira_allocnos[ALLOCNO_NUM (a)] = NULL; if (ALLOCNO_HARD_REG_COSTS (a) != NULL) - ira_free_cost_vector (ALLOCNO_HARD_REG_COSTS (a), cover_class); + ira_free_cost_vector (ALLOCNO_HARD_REG_COSTS (a), aclass); if (ALLOCNO_CONFLICT_HARD_REG_COSTS (a) != NULL) - ira_free_cost_vector (ALLOCNO_CONFLICT_HARD_REG_COSTS (a), cover_class); + ira_free_cost_vector (ALLOCNO_CONFLICT_HARD_REG_COSTS (a), aclass); if (ALLOCNO_UPDATED_HARD_REG_COSTS (a) != NULL) - ira_free_cost_vector (ALLOCNO_UPDATED_HARD_REG_COSTS (a), cover_class); + ira_free_cost_vector (ALLOCNO_UPDATED_HARD_REG_COSTS (a), aclass); if (ALLOCNO_UPDATED_CONFLICT_HARD_REG_COSTS (a) != NULL) ira_free_cost_vector (ALLOCNO_UPDATED_CONFLICT_HARD_REG_COSTS (a), - cover_class); + aclass); + ALLOCNO_HARD_REG_COSTS (a) = NULL; + ALLOCNO_CONFLICT_HARD_REG_COSTS (a) = NULL; + ALLOCNO_UPDATED_HARD_REG_COSTS (a) = NULL; + ALLOCNO_UPDATED_CONFLICT_HARD_REG_COSTS (a) = NULL; +} + +/* Free the memory allocated for allocno A. */ +static void +finish_allocno (ira_allocno_t a) +{ + ira_free_allocno_costs (a); pool_free (allocno_pool, a); } @@ -1365,55 +1379,54 @@ finish_copies (void) -/* Pools for cost vectors. It is defined only for cover classes. */ +/* Pools for cost vectors. It is defined only for allocno classes. */ static alloc_pool cost_vector_pool[N_REG_CLASSES]; /* The function initiates work with hard register cost vectors. It - creates allocation pool for each cover class. */ + creates allocation pool for each allocno class. */ static void initiate_cost_vectors (void) { int i; - enum reg_class cover_class; + enum reg_class aclass; - for (i = 0; i < ira_reg_class_cover_size; i++) + for (i = 0; i < ira_allocno_classes_num; i++) { - cover_class = ira_reg_class_cover[i]; - cost_vector_pool[cover_class] + aclass = ira_allocno_classes[i]; + cost_vector_pool[aclass] = create_alloc_pool ("cost vectors", - sizeof (int) - * ira_class_hard_regs_num[cover_class], + sizeof (int) * ira_class_hard_regs_num[aclass], 100); } } -/* Allocate and return a cost vector VEC for COVER_CLASS. */ +/* Allocate and return a cost vector VEC for ACLASS. */ int * -ira_allocate_cost_vector (enum reg_class cover_class) +ira_allocate_cost_vector (enum reg_class aclass) { - return (int *) pool_alloc (cost_vector_pool[cover_class]); + return (int *) pool_alloc (cost_vector_pool[aclass]); } -/* Free a cost vector VEC for COVER_CLASS. */ +/* Free a cost vector VEC for ACLASS. */ void -ira_free_cost_vector (int *vec, enum reg_class cover_class) +ira_free_cost_vector (int *vec, enum reg_class aclass) { ira_assert (vec != NULL); - pool_free (cost_vector_pool[cover_class], vec); + pool_free (cost_vector_pool[aclass], vec); } /* Finish work with hard register cost vectors. Release allocation - pool for each cover class. */ + pool for each allocno class. */ static void finish_cost_vectors (void) { int i; - enum reg_class cover_class; + enum reg_class aclass; - for (i = 0; i < ira_reg_class_cover_size; i++) + for (i = 0; i < ira_allocno_classes_num; i++) { - cover_class = ira_reg_class_cover[i]; - free_alloc_pool (cost_vector_pool[cover_class]); + aclass = ira_allocno_classes[i]; + free_alloc_pool (cost_vector_pool[aclass]); } } @@ -1644,7 +1657,7 @@ propagate_allocno_info (void) int i; ira_allocno_t a, parent_a; ira_loop_tree_node_t parent; - enum reg_class cover_class; + enum reg_class aclass; if (flag_ira_region != IRA_REGION_ALL && flag_ira_region != IRA_REGION_MIXED) @@ -1670,17 +1683,17 @@ propagate_allocno_info (void) += ALLOCNO_CALLS_CROSSED_NUM (a); ALLOCNO_EXCESS_PRESSURE_POINTS_NUM (parent_a) += ALLOCNO_EXCESS_PRESSURE_POINTS_NUM (a); - cover_class = ALLOCNO_COVER_CLASS (a); - ira_assert (cover_class == ALLOCNO_COVER_CLASS (parent_a)); + aclass = ALLOCNO_CLASS (a); + ira_assert (aclass == ALLOCNO_CLASS (parent_a)); ira_allocate_and_accumulate_costs - (&ALLOCNO_HARD_REG_COSTS (parent_a), cover_class, + (&ALLOCNO_HARD_REG_COSTS (parent_a), aclass, ALLOCNO_HARD_REG_COSTS (a)); ira_allocate_and_accumulate_costs (&ALLOCNO_CONFLICT_HARD_REG_COSTS (parent_a), - cover_class, + aclass, ALLOCNO_CONFLICT_HARD_REG_COSTS (a)); - ALLOCNO_COVER_CLASS_COST (parent_a) - += ALLOCNO_COVER_CLASS_COST (a); + ALLOCNO_CLASS_COST (parent_a) + += ALLOCNO_CLASS_COST (a); ALLOCNO_MEMORY_COST (parent_a) += ALLOCNO_MEMORY_COST (a); } } @@ -1778,16 +1791,16 @@ static bool low_pressure_loop_node_p (ira_loop_tree_node_t node) { int i; - enum reg_class cover_class; + enum reg_class pclass; if (node->bb != NULL) return false; - for (i = 0; i < ira_reg_class_cover_size; i++) + for (i = 0; i < ira_pressure_classes_num; i++) { - cover_class = ira_reg_class_cover[i]; - if (node->reg_pressure[cover_class] - > ira_available_class_regs[cover_class]) + pclass = ira_pressure_classes[i]; + if (node->reg_pressure[pclass] > ira_available_class_regs[pclass] + && ira_available_class_regs[pclass] > 1) return false; } return true; @@ -2003,7 +2016,7 @@ ira_rebuild_regno_allocno_list (int regno) static void propagate_some_info_from_allocno (ira_allocno_t a, ira_allocno_t from_a) { - enum reg_class cover_class; + enum reg_class aclass; merge_hard_reg_conflicts (from_a, a, false); ALLOCNO_NREFS (a) += ALLOCNO_NREFS (from_a); @@ -2014,14 +2027,14 @@ propagate_some_info_from_allocno (ira_allocno_t a, ira_allocno_t from_a) += ALLOCNO_EXCESS_PRESSURE_POINTS_NUM (from_a); if (! ALLOCNO_BAD_SPILL_P (from_a)) ALLOCNO_BAD_SPILL_P (a) = false; - cover_class = ALLOCNO_COVER_CLASS (from_a); - ira_assert (cover_class == ALLOCNO_COVER_CLASS (a)); - ira_allocate_and_accumulate_costs (&ALLOCNO_HARD_REG_COSTS (a), cover_class, + aclass = ALLOCNO_CLASS (from_a); + ira_assert (aclass == ALLOCNO_CLASS (a)); + ira_allocate_and_accumulate_costs (&ALLOCNO_HARD_REG_COSTS (a), aclass, ALLOCNO_HARD_REG_COSTS (from_a)); ira_allocate_and_accumulate_costs (&ALLOCNO_CONFLICT_HARD_REG_COSTS (a), - cover_class, + aclass, ALLOCNO_CONFLICT_HARD_REG_COSTS (from_a)); - ALLOCNO_COVER_CLASS_COST (a) += ALLOCNO_COVER_CLASS_COST (from_a); + ALLOCNO_CLASS_COST (a) += ALLOCNO_CLASS_COST (from_a); ALLOCNO_MEMORY_COST (a) += ALLOCNO_MEMORY_COST (from_a); } @@ -2173,8 +2186,8 @@ remove_low_level_allocnos (void) /* Remove loops from consideration. We remove all loops except for root if ALL_P or loops for which a separate allocation will not improve the result. We have to do this after allocno creation and - their costs and cover class evaluation because only after that the - register pressure can be known and is calculated. */ + their costs and allocno class evaluation because only after that + the register pressure can be known and is calculated. */ static void remove_unnecessary_regions (bool all_p) { @@ -2223,27 +2236,27 @@ update_bad_spill_attribute (void) ira_allocno_object_iterator aoi; ira_object_t obj; live_range_t r; - enum reg_class cover_class; + enum reg_class aclass; bitmap_head dead_points[N_REG_CLASSES]; - for (i = 0; i < ira_reg_class_cover_size; i++) + for (i = 0; i < ira_allocno_classes_num; i++) { - cover_class = ira_reg_class_cover[i]; - bitmap_initialize (&dead_points[cover_class], ®_obstack); + aclass = ira_allocno_classes[i]; + bitmap_initialize (&dead_points[aclass], ®_obstack); } FOR_EACH_ALLOCNO (a, ai) { - cover_class = ALLOCNO_COVER_CLASS (a); - if (cover_class == NO_REGS) + aclass = ALLOCNO_CLASS (a); + if (aclass == NO_REGS) continue; FOR_EACH_ALLOCNO_OBJECT (a, obj, aoi) for (r = OBJECT_LIVE_RANGES (obj); r != NULL; r = r->next) - bitmap_set_bit (&dead_points[cover_class], r->finish); + bitmap_set_bit (&dead_points[aclass], r->finish); } FOR_EACH_ALLOCNO (a, ai) { - cover_class = ALLOCNO_COVER_CLASS (a); - if (cover_class == NO_REGS) + aclass = ALLOCNO_CLASS (a); + if (aclass == NO_REGS) continue; if (! ALLOCNO_BAD_SPILL_P (a)) continue; @@ -2252,7 +2265,7 @@ update_bad_spill_attribute (void) for (r = OBJECT_LIVE_RANGES (obj); r != NULL; r = r->next) { for (i = r->start + 1; i < r->finish; i++) - if (bitmap_bit_p (&dead_points[cover_class], i)) + if (bitmap_bit_p (&dead_points[aclass], i)) break; if (i < r->finish) break; @@ -2264,10 +2277,10 @@ update_bad_spill_attribute (void) } } } - for (i = 0; i < ira_reg_class_cover_size; i++) + for (i = 0; i < ira_allocno_classes_num; i++) { - cover_class = ira_reg_class_cover[i]; - bitmap_clear (&dead_points[cover_class]); + aclass = ira_allocno_classes[i]; + bitmap_clear (&dead_points[aclass]); } } @@ -2290,6 +2303,7 @@ setup_min_max_allocno_live_range_point (void) FOR_EACH_ALLOCNO (a, ai) { int n = ALLOCNO_NUM_OBJECTS (a); + for (i = 0; i < n; i++) { ira_object_t obj = ALLOCNO_OBJECT (a, i); @@ -2309,6 +2323,7 @@ setup_min_max_allocno_live_range_point (void) { int j; int n = ALLOCNO_NUM_OBJECTS (a); + for (j = 0; j < n; j++) { ira_object_t obj = ALLOCNO_OBJECT (a, j); @@ -2352,10 +2367,10 @@ setup_min_max_allocno_live_range_point (void) } /* Sort allocnos according to their live ranges. Allocnos with - smaller cover class are put first unless we use priority coloring. - Allocnos with the same cover class are ordered according their start - (min). Allocnos with the same start are ordered according their - finish (max). */ + smaller allocno class are put first unless we use priority + coloring. Allocnos with the same class are ordered according + their start (min). Allocnos with the same start are ordered + according their finish (max). */ static int object_range_compare_func (const void *v1p, const void *v2p) { @@ -2365,9 +2380,6 @@ object_range_compare_func (const void *v1p, const void *v2p) ira_allocno_t a1 = OBJECT_ALLOCNO (obj1); ira_allocno_t a2 = OBJECT_ALLOCNO (obj2); - if (flag_ira_algorithm != IRA_ALGORITHM_PRIORITY - && (diff = ALLOCNO_COVER_CLASS (a1) - ALLOCNO_COVER_CLASS (a2)) != 0) - return diff; if ((diff = OBJECT_MIN (obj1) - OBJECT_MIN (obj2)) != 0) return diff; if ((diff = OBJECT_MAX (obj1) - OBJECT_MAX (obj2)) != 0) @@ -2397,6 +2409,7 @@ sort_conflict_id_map (void) for (i = 0; i < num; i++) { ira_object_t obj = ira_object_id_map[i]; + gcc_assert (obj != NULL); OBJECT_CONFLICT_ID (obj) = i; } @@ -2409,7 +2422,7 @@ sort_conflict_id_map (void) static void setup_min_max_conflict_allocno_ids (void) { - int cover_class; + int aclass; int i, j, min, max, start, finish, first_not_finished, filled_area_start; int *live_range_min, *last_lived; int word0_min, word0_max; @@ -2417,21 +2430,20 @@ setup_min_max_conflict_allocno_ids (void) ira_allocno_iterator ai; live_range_min = (int *) ira_allocate (sizeof (int) * ira_objects_num); - cover_class = -1; + aclass = -1; first_not_finished = -1; for (i = 0; i < ira_objects_num; i++) { ira_object_t obj = ira_object_id_map[i]; + if (obj == NULL) continue; a = OBJECT_ALLOCNO (obj); - if (cover_class < 0 - || (flag_ira_algorithm != IRA_ALGORITHM_PRIORITY - && cover_class != (int) ALLOCNO_COVER_CLASS (a))) + if (aclass < 0) { - cover_class = ALLOCNO_COVER_CLASS (a); + aclass = ALLOCNO_CLASS (a); min = i; first_not_finished = i; } @@ -2456,20 +2468,19 @@ setup_min_max_conflict_allocno_ids (void) OBJECT_MIN (obj) = min; } last_lived = (int *) ira_allocate (sizeof (int) * ira_max_point); - cover_class = -1; + aclass = -1; filled_area_start = -1; for (i = ira_objects_num - 1; i >= 0; i--) { ira_object_t obj = ira_object_id_map[i]; + if (obj == NULL) continue; a = OBJECT_ALLOCNO (obj); - if (cover_class < 0 - || (flag_ira_algorithm != IRA_ALGORITHM_PRIORITY - && cover_class != (int) ALLOCNO_COVER_CLASS (a))) + if (aclass < 0) { - cover_class = ALLOCNO_COVER_CLASS (a); + aclass = ALLOCNO_CLASS (a); for (j = 0; j < ira_max_point; j++) last_lived[j] = -1; filled_area_start = ira_max_point; @@ -2507,6 +2518,7 @@ setup_min_max_conflict_allocno_ids (void) { int n = ALLOCNO_NUM_OBJECTS (a); ira_object_t obj0; + if (n < 2) continue; obj0 = ALLOCNO_OBJECT (a, 0); @@ -2519,6 +2531,7 @@ setup_min_max_conflict_allocno_ids (void) { int n = ALLOCNO_NUM_OBJECTS (a); ira_object_t obj0; + if (n < 2) continue; obj0 = ALLOCNO_OBJECT (a, 0); @@ -2611,7 +2624,7 @@ copy_info_to_removed_store_destinations (int regno) a != NULL; a = ALLOCNO_NEXT_REGNO_ALLOCNO (a)) { - if (a != regno_top_level_allocno_map[REGNO (ALLOCNO_REG (a))]) + if (a != regno_top_level_allocno_map[REGNO (allocno_emit_reg (a))]) /* This allocno will be removed. */ continue; @@ -2621,9 +2634,10 @@ copy_info_to_removed_store_destinations (int regno) parent != NULL; parent = parent->parent) if ((parent_a = parent->regno_allocno_map[regno]) == NULL - || (parent_a == regno_top_level_allocno_map[REGNO (ALLOCNO_REG - (parent_a))] - && ALLOCNO_MEM_OPTIMIZED_DEST_P (parent_a))) + || (parent_a + == regno_top_level_allocno_map[REGNO + (allocno_emit_reg (parent_a))] + && ALLOCNO_EMIT_DATA (parent_a)->mem_optimized_dest_p)) break; if (parent == NULL || parent_a == NULL) continue; @@ -2655,7 +2669,7 @@ ira_flattening (int max_regno_before_emit, int ira_max_point_before_emit) int hard_regs_num; bool new_pseudos_p, merged_p, mem_dest_p; unsigned int n; - enum reg_class cover_class; + enum reg_class aclass; ira_allocno_t a, parent_a, first, second, node_first, node_second; ira_copy_t cp; ira_loop_tree_node_t node; @@ -2664,7 +2678,8 @@ ira_flattening (int max_regno_before_emit, int ira_max_point_before_emit) ira_copy_iterator ci; regno_top_level_allocno_map - = (ira_allocno_t *) ira_allocate (max_reg_num () * sizeof (ira_allocno_t)); + = (ira_allocno_t *) ira_allocate (max_reg_num () + * sizeof (ira_allocno_t)); memset (regno_top_level_allocno_map, 0, max_reg_num () * sizeof (ira_allocno_t)); new_pseudos_p = merged_p = false; @@ -2672,6 +2687,7 @@ ira_flattening (int max_regno_before_emit, int ira_max_point_before_emit) { ira_allocno_object_iterator oi; ira_object_t obj; + if (ALLOCNO_CAP_MEMBER (a) != NULL) /* Caps are not in the regno allocno maps and they are never will be transformed into allocnos existing after IR @@ -2692,28 +2708,31 @@ ira_flattening (int max_regno_before_emit, int ira_max_point_before_emit) a != NULL; a = ALLOCNO_NEXT_REGNO_ALLOCNO (a)) { + ira_emit_data_t parent_data, data = ALLOCNO_EMIT_DATA (a); + ira_assert (ALLOCNO_CAP_MEMBER (a) == NULL); - if (ALLOCNO_SOMEWHERE_RENAMED_P (a)) + if (data->somewhere_renamed_p) new_pseudos_p = true; parent_a = ira_parent_allocno (a); if (parent_a == NULL) { ALLOCNO_COPIES (a) = NULL; - regno_top_level_allocno_map[REGNO (ALLOCNO_REG (a))] = a; + regno_top_level_allocno_map[REGNO (data->reg)] = a; continue; } ira_assert (ALLOCNO_CAP_MEMBER (parent_a) == NULL); - if (ALLOCNO_MEM_OPTIMIZED_DEST (a) != NULL) + if (data->mem_optimized_dest != NULL) mem_dest_p = true; - if (REGNO (ALLOCNO_REG (a)) == REGNO (ALLOCNO_REG (parent_a))) + parent_data = ALLOCNO_EMIT_DATA (parent_a); + if (REGNO (data->reg) == REGNO (parent_data->reg)) { merge_hard_reg_conflicts (a, parent_a, true); move_allocno_live_ranges (a, parent_a); merged_p = true; - ALLOCNO_MEM_OPTIMIZED_DEST_P (parent_a) - = (ALLOCNO_MEM_OPTIMIZED_DEST_P (parent_a) - || ALLOCNO_MEM_OPTIMIZED_DEST_P (a)); + parent_data->mem_optimized_dest_p + = (parent_data->mem_optimized_dest_p + || data->mem_optimized_dest_p); continue; } new_pseudos_p = true; @@ -2729,8 +2748,8 @@ ira_flattening (int max_regno_before_emit, int ira_max_point_before_emit) ira_assert (ALLOCNO_CALLS_CROSSED_NUM (parent_a) >= 0 && ALLOCNO_NREFS (parent_a) >= 0 && ALLOCNO_FREQ (parent_a) >= 0); - cover_class = ALLOCNO_COVER_CLASS (parent_a); - hard_regs_num = ira_class_hard_regs_num[cover_class]; + aclass = ALLOCNO_CLASS (parent_a); + hard_regs_num = ira_class_hard_regs_num[aclass]; if (ALLOCNO_HARD_REG_COSTS (a) != NULL && ALLOCNO_HARD_REG_COSTS (parent_a) != NULL) for (j = 0; j < hard_regs_num; j++) @@ -2741,15 +2760,15 @@ ira_flattening (int max_regno_before_emit, int ira_max_point_before_emit) for (j = 0; j < hard_regs_num; j++) ALLOCNO_CONFLICT_HARD_REG_COSTS (parent_a)[j] -= ALLOCNO_CONFLICT_HARD_REG_COSTS (a)[j]; - ALLOCNO_COVER_CLASS_COST (parent_a) - -= ALLOCNO_COVER_CLASS_COST (a); + ALLOCNO_CLASS_COST (parent_a) + -= ALLOCNO_CLASS_COST (a); ALLOCNO_MEMORY_COST (parent_a) -= ALLOCNO_MEMORY_COST (a); parent_a = ira_parent_allocno (parent_a); if (parent_a == NULL) break; } ALLOCNO_COPIES (a) = NULL; - regno_top_level_allocno_map[REGNO (ALLOCNO_REG (a))] = a; + regno_top_level_allocno_map[REGNO (data->reg)] = a; } if (mem_dest_p && copy_info_to_removed_store_destinations (i)) merged_p = true; @@ -2766,7 +2785,8 @@ ira_flattening (int max_regno_before_emit, int ira_max_point_before_emit) { ira_allocno_object_iterator oi; ira_object_t obj; - if (a != regno_top_level_allocno_map[REGNO (ALLOCNO_REG (a))] + + if (a != regno_top_level_allocno_map[REGNO (allocno_emit_reg (a))] || ALLOCNO_CAP_MEMBER (a) != NULL) continue; FOR_EACH_ALLOCNO_OBJECT (a, obj, oi) @@ -2782,19 +2802,21 @@ ira_flattening (int max_regno_before_emit, int ira_max_point_before_emit) for (r = ira_start_point_ranges[i]; r != NULL; r = r->start_next) { ira_object_t obj = r->object; + a = OBJECT_ALLOCNO (obj); - if (a != regno_top_level_allocno_map[REGNO (ALLOCNO_REG (a))] + if (a != regno_top_level_allocno_map[REGNO (allocno_emit_reg (a))] || ALLOCNO_CAP_MEMBER (a) != NULL) continue; - cover_class = ALLOCNO_COVER_CLASS (a); + aclass = ALLOCNO_CLASS (a); sparseset_set_bit (objects_live, OBJECT_CONFLICT_ID (obj)); EXECUTE_IF_SET_IN_SPARSESET (objects_live, n) { ira_object_t live_obj = ira_object_id_map[n]; ira_allocno_t live_a = OBJECT_ALLOCNO (live_obj); - enum reg_class live_cover = ALLOCNO_COVER_CLASS (live_a); - if (ira_reg_classes_intersect_p[cover_class][live_cover] + enum reg_class live_aclass = ALLOCNO_CLASS (live_a); + + if (ira_reg_classes_intersect_p[aclass][live_aclass] /* Don't set up conflict for the allocno with itself. */ && live_a != a) ira_add_conflict (obj, live_obj); @@ -2818,14 +2840,18 @@ ira_flattening (int max_regno_before_emit, int ira_max_point_before_emit) fprintf (ira_dump_file, " Remove cp%d:%c%dr%d-%c%dr%d\n", cp->num, ALLOCNO_CAP_MEMBER (cp->first) != NULL ? 'c' : 'a', - ALLOCNO_NUM (cp->first), REGNO (ALLOCNO_REG (cp->first)), + ALLOCNO_NUM (cp->first), + REGNO (allocno_emit_reg (cp->first)), ALLOCNO_CAP_MEMBER (cp->second) != NULL ? 'c' : 'a', - ALLOCNO_NUM (cp->second), REGNO (ALLOCNO_REG (cp->second))); + ALLOCNO_NUM (cp->second), + REGNO (allocno_emit_reg (cp->second))); cp->loop_tree_node = NULL; continue; } - first = regno_top_level_allocno_map[REGNO (ALLOCNO_REG (cp->first))]; - second = regno_top_level_allocno_map[REGNO (ALLOCNO_REG (cp->second))]; + first + = regno_top_level_allocno_map[REGNO (allocno_emit_reg (cp->first))]; + second + = regno_top_level_allocno_map[REGNO (allocno_emit_reg (cp->second))]; node = cp->loop_tree_node; if (node == NULL) keep_p = true; /* It copy generated in ira-emit.c. */ @@ -2835,10 +2861,10 @@ ira_flattening (int max_regno_before_emit, int ira_max_point_before_emit) which we will have different pseudos. */ node_first = node->regno_allocno_map[ALLOCNO_REGNO (cp->first)]; node_second = node->regno_allocno_map[ALLOCNO_REGNO (cp->second)]; - keep_p = ((REGNO (ALLOCNO_REG (first)) - == REGNO (ALLOCNO_REG (node_first))) - && (REGNO (ALLOCNO_REG (second)) - == REGNO (ALLOCNO_REG (node_second)))); + keep_p = ((REGNO (allocno_emit_reg (first)) + == REGNO (allocno_emit_reg (node_first))) + && (REGNO (allocno_emit_reg (second)) + == REGNO (allocno_emit_reg (node_second)))); } if (keep_p) { @@ -2852,28 +2878,29 @@ ira_flattening (int max_regno_before_emit, int ira_max_point_before_emit) if (internal_flag_ira_verbose > 4 && ira_dump_file != NULL) fprintf (ira_dump_file, " Remove cp%d:a%dr%d-a%dr%d\n", cp->num, ALLOCNO_NUM (cp->first), - REGNO (ALLOCNO_REG (cp->first)), ALLOCNO_NUM (cp->second), - REGNO (ALLOCNO_REG (cp->second))); + REGNO (allocno_emit_reg (cp->first)), + ALLOCNO_NUM (cp->second), + REGNO (allocno_emit_reg (cp->second))); } } /* Remove unnecessary allocnos on lower levels of the loop tree. */ FOR_EACH_ALLOCNO (a, ai) { - if (a != regno_top_level_allocno_map[REGNO (ALLOCNO_REG (a))] + if (a != regno_top_level_allocno_map[REGNO (allocno_emit_reg (a))] || ALLOCNO_CAP_MEMBER (a) != NULL) { if (internal_flag_ira_verbose > 4 && ira_dump_file != NULL) fprintf (ira_dump_file, " Remove a%dr%d\n", - ALLOCNO_NUM (a), REGNO (ALLOCNO_REG (a))); + ALLOCNO_NUM (a), REGNO (allocno_emit_reg (a))); finish_allocno (a); continue; } ALLOCNO_LOOP_TREE_NODE (a) = ira_loop_tree_root; - ALLOCNO_REGNO (a) = REGNO (ALLOCNO_REG (a)); + ALLOCNO_REGNO (a) = REGNO (allocno_emit_reg (a)); ALLOCNO_CAP (a) = NULL; /* Restore updated costs for assignments from reload. */ ALLOCNO_UPDATED_MEMORY_COST (a) = ALLOCNO_MEMORY_COST (a); - ALLOCNO_UPDATED_COVER_CLASS_COST (a) = ALLOCNO_COVER_CLASS_COST (a); + ALLOCNO_UPDATED_CLASS_COST (a) = ALLOCNO_CLASS_COST (a); if (! ALLOCNO_ASSIGNED_P (a)) ira_free_allocno_updated_costs (a); ira_assert (ALLOCNO_UPDATED_HARD_REG_COSTS (a) == NULL); @@ -2942,29 +2969,28 @@ update_conflict_hard_reg_costs (void) FOR_EACH_ALLOCNO (a, ai) { - enum reg_class cover_class = ALLOCNO_COVER_CLASS (a); + enum reg_class aclass = ALLOCNO_CLASS (a); enum reg_class pref = reg_preferred_class (ALLOCNO_REGNO (a)); if (reg_class_size[pref] != 1) continue; - index = (ira_class_hard_reg_index[cover_class] - [ira_class_hard_regs[pref][0]]); + index = ira_class_hard_reg_index[aclass][ira_class_hard_regs[pref][0]]; if (index < 0) continue; if (ALLOCNO_CONFLICT_HARD_REG_COSTS (a) == NULL || ALLOCNO_HARD_REG_COSTS (a) == NULL) continue; min = INT_MAX; - for (i = ira_class_hard_regs_num[cover_class] - 1; i >= 0; i--) - if (ALLOCNO_HARD_REG_COSTS (a)[i] > ALLOCNO_COVER_CLASS_COST (a) + for (i = ira_class_hard_regs_num[aclass] - 1; i >= 0; i--) + if (ALLOCNO_HARD_REG_COSTS (a)[i] > ALLOCNO_CLASS_COST (a) && min > ALLOCNO_HARD_REG_COSTS (a)[i]) min = ALLOCNO_HARD_REG_COSTS (a)[i]; if (min == INT_MAX) continue; ira_allocate_and_set_costs (&ALLOCNO_CONFLICT_HARD_REG_COSTS (a), - cover_class, 0); + aclass, 0); ALLOCNO_CONFLICT_HARD_REG_COSTS (a)[index] - -= min - ALLOCNO_COVER_CLASS_COST (a); + -= min - ALLOCNO_CLASS_COST (a); } } @@ -3000,7 +3026,7 @@ ira_build (bool loops_p) propagate_allocno_info (); create_caps (); } - ira_tune_allocno_costs_and_cover_classes (); + ira_tune_allocno_costs (); #ifdef ENABLE_IRA_CHECKING check_allocno_creation (); #endif @@ -3042,6 +3068,7 @@ ira_build (bool loops_p) FOR_EACH_ALLOCNO (a, ai) { int j, nobj = ALLOCNO_NUM_OBJECTS (a); + if (nobj > 1) nr_big++; for (j = 0; j < nobj; j++) |