This is another patch to remove "allocno" from names, this time involving live ranges. Subsequent patches will change IRA to associate live ranges with other objects than allocnos; even without that motivation I believe that the code becomes more readable due to the shorter identifiers. There's really no need to call a live range an allocno_live_range. * ira-int.h (struct live_range, live_range_t): Renamed from struct ira_allocno_live_range and allocno_live_range_t; all uses changed. * ira-build.c (live_range_pool): Renamed from allocno_live_range_pool. All uses changed. Index: gcc/ira-build.c =================================================================== --- gcc.orig/ira-build.c +++ gcc/ira-build.c @@ -383,8 +383,8 @@ rebuild_regno_allocno_maps (void) -/* Pools for allocnos and allocno live ranges. */ -static alloc_pool allocno_pool, allocno_live_range_pool; +/* Pools for allocnos and live ranges. */ +static alloc_pool allocno_pool, live_range_pool; /* Vec containing references to all created allocnos. It is a container of array allocnos. */ @@ -398,9 +398,9 @@ static VEC(ira_allocno_t,heap) *ira_conf static void initiate_allocnos (void) { - allocno_live_range_pool - = create_alloc_pool ("allocno live ranges", - sizeof (struct ira_allocno_live_range), 100); + live_range_pool + = create_alloc_pool ("live ranges", + sizeof (struct live_range), 100); allocno_pool = create_alloc_pool ("allocnos", sizeof (struct ira_allocno), 100); allocno_vec = VEC_alloc (ira_allocno_t, heap, max_reg_num () * 2); @@ -812,13 +812,13 @@ create_cap_allocno (ira_allocno_t a) } /* Create and return allocno live range with given attributes. */ -allocno_live_range_t +live_range_t ira_create_allocno_live_range (ira_allocno_t a, int start, int finish, - allocno_live_range_t next) + live_range_t next) { - allocno_live_range_t p; + live_range_t p; - p = (allocno_live_range_t) pool_alloc (allocno_live_range_pool); + p = (live_range_t) pool_alloc (live_range_pool); p->allocno = a; p->start = start; p->finish = finish; @@ -827,22 +827,22 @@ ira_create_allocno_live_range (ira_alloc } /* Copy allocno live range R and return the result. */ -static allocno_live_range_t -copy_allocno_live_range (allocno_live_range_t r) +static live_range_t +copy_allocno_live_range (live_range_t r) { - allocno_live_range_t p; + live_range_t p; - p = (allocno_live_range_t) pool_alloc (allocno_live_range_pool); + p = (live_range_t) pool_alloc (live_range_pool); *p = *r; return p; } /* Copy allocno live range list given by its head R and return the result. */ -allocno_live_range_t -ira_copy_allocno_live_range_list (allocno_live_range_t r) +live_range_t +ira_copy_allocno_live_range_list (live_range_t r) { - allocno_live_range_t p, first, last; + live_range_t p, first, last; if (r == NULL) return NULL; @@ -861,11 +861,10 @@ ira_copy_allocno_live_range_list (allocn /* Merge ranges R1 and R2 and returns the result. The function maintains the order of ranges and tries to minimize number of the result ranges. */ -allocno_live_range_t -ira_merge_allocno_live_ranges (allocno_live_range_t r1, - allocno_live_range_t r2) +live_range_t +ira_merge_allocno_live_ranges (live_range_t r1, live_range_t r2) { - allocno_live_range_t first, last, temp; + live_range_t first, last, temp; if (r1 == NULL) return r2; @@ -939,8 +938,7 @@ ira_merge_allocno_live_ranges (allocno_l /* Return TRUE if live ranges R1 and R2 intersect. */ bool -ira_allocno_live_ranges_intersect_p (allocno_live_range_t r1, - allocno_live_range_t r2) +ira_allocno_live_ranges_intersect_p (live_range_t r1, live_range_t r2) { /* Remember the live ranges are always kept ordered. */ while (r1 != NULL && r2 != NULL) @@ -957,16 +955,16 @@ ira_allocno_live_ranges_intersect_p (all /* Free allocno live range R. */ void -ira_finish_allocno_live_range (allocno_live_range_t r) +ira_finish_allocno_live_range (live_range_t r) { - pool_free (allocno_live_range_pool, r); + pool_free (live_range_pool, r); } /* Free list of allocno live ranges starting with R. */ void -ira_finish_allocno_live_range_list (allocno_live_range_t r) +ira_finish_allocno_live_range_list (live_range_t r) { - allocno_live_range_t next_r; + live_range_t next_r; for (; r != NULL; r = next_r) { @@ -1027,7 +1025,7 @@ finish_allocnos (void) VEC_free (ira_allocno_t, heap, ira_conflict_id_allocno_map_vec); VEC_free (ira_allocno_t, heap, allocno_vec); free_alloc_pool (allocno_pool); - free_alloc_pool (allocno_live_range_pool); + free_alloc_pool (live_range_pool); } @@ -1658,7 +1656,7 @@ create_allocnos (void) /* The function changes allocno in range list given by R onto A. */ static void -change_allocno_in_range_list (allocno_live_range_t r, ira_allocno_t a) +change_allocno_in_range_list (live_range_t r, ira_allocno_t a) { for (; r != NULL; r = r->next) r->allocno = a; @@ -1668,7 +1666,7 @@ change_allocno_in_range_list (allocno_li static void move_allocno_live_ranges (ira_allocno_t from, ira_allocno_t to) { - allocno_live_range_t lr = ALLOCNO_LIVE_RANGES (from); + live_range_t lr = ALLOCNO_LIVE_RANGES (from); if (internal_flag_ira_verbose > 4 && ira_dump_file != NULL) { @@ -1688,7 +1686,7 @@ move_allocno_live_ranges (ira_allocno_t static void copy_allocno_live_ranges (ira_allocno_t from, ira_allocno_t to) { - allocno_live_range_t lr = ALLOCNO_LIVE_RANGES (from); + live_range_t lr = ALLOCNO_LIVE_RANGES (from); if (internal_flag_ira_verbose > 4 && ira_dump_file != NULL) { @@ -2148,7 +2146,7 @@ update_bad_spill_attribute (void) int i; ira_allocno_t a; ira_allocno_iterator ai; - allocno_live_range_t r; + live_range_t r; enum reg_class cover_class; bitmap_head dead_points[N_REG_CLASSES]; @@ -2199,7 +2197,7 @@ setup_min_max_allocno_live_range_point ( int i; ira_allocno_t a, parent_a, cap; ira_allocno_iterator ai; - allocno_live_range_t r; + live_range_t r; ira_loop_tree_node_t parent; FOR_EACH_ALLOCNO (a, ai) @@ -2496,7 +2494,7 @@ ira_flattening (int max_regno_before_emi ira_allocno_t a, parent_a, first, second, node_first, node_second; ira_copy_t cp; ira_loop_tree_node_t node; - allocno_live_range_t r; + live_range_t r; ira_allocno_iterator ai; ira_copy_iterator ci; sparseset allocnos_live; @@ -2864,7 +2862,7 @@ ira_build (bool loops_p) { int n, nr; ira_allocno_t a; - allocno_live_range_t r; + live_range_t r; ira_allocno_iterator ai; n = 0; Index: gcc/ira-color.c =================================================================== --- gcc.orig/ira-color.c +++ gcc/ira-color.c @@ -2493,7 +2493,7 @@ collect_spilled_coalesced_allocnos (int /* Array of live ranges of size IRA_ALLOCNOS_NUM. Live range for given slot contains live ranges of coalesced allocnos assigned to given slot. */ -static allocno_live_range_t *slot_coalesced_allocnos_live_ranges; +static live_range_t *slot_coalesced_allocnos_live_ranges; /* Return TRUE if coalesced allocnos represented by ALLOCNO has live ranges intersected with live ranges of coalesced allocnos assigned @@ -2522,7 +2522,7 @@ setup_slot_coalesced_allocno_live_ranges { int n; ira_allocno_t a; - allocno_live_range_t r; + live_range_t r; n = ALLOCNO_TEMP (allocno); for (a = ALLOCNO_NEXT_COALESCED_ALLOCNO (allocno);; @@ -2551,10 +2551,9 @@ coalesce_spill_slots (ira_allocno_t *spi bitmap set_jump_crosses = regstat_get_setjmp_crosses (); slot_coalesced_allocnos_live_ranges - = (allocno_live_range_t *) ira_allocate (sizeof (allocno_live_range_t) - * ira_allocnos_num); + = (live_range_t *) ira_allocate (sizeof (live_range_t) * ira_allocnos_num); memset (slot_coalesced_allocnos_live_ranges, 0, - sizeof (allocno_live_range_t) * ira_allocnos_num); + sizeof (live_range_t) * ira_allocnos_num); last_coalesced_allocno_num = 0; /* Coalesce non-conflicting spilled allocnos preferring most frequently used. */ @@ -3244,7 +3243,7 @@ fast_allocation (void) enum machine_mode mode; ira_allocno_t a; ira_allocno_iterator ai; - allocno_live_range_t r; + live_range_t r; HARD_REG_SET conflict_hard_regs, *used_hard_regs; sorted_allocnos = (ira_allocno_t *) ira_allocate (sizeof (ira_allocno_t) Index: gcc/ira-conflicts.c =================================================================== --- gcc.orig/ira-conflicts.c +++ gcc/ira-conflicts.c @@ -71,7 +71,7 @@ build_conflict_bit_table (void) unsigned int j; enum reg_class cover_class; ira_allocno_t allocno, live_a; - allocno_live_range_t r; + live_range_t r; ira_allocno_iterator ai; sparseset allocnos_live; int allocno_set_words; Index: gcc/ira-emit.c =================================================================== --- gcc.orig/ira-emit.c +++ gcc/ira-emit.c @@ -913,7 +913,7 @@ add_range_and_copies_from_move_list (mov move_t move; ira_allocno_t to, from, a; ira_copy_t cp; - allocno_live_range_t r; + live_range_t r; bitmap_iterator bi; HARD_REG_SET hard_regs_live; Index: gcc/ira-int.h =================================================================== --- gcc.orig/ira-int.h +++ gcc/ira-int.h @@ -59,7 +59,7 @@ extern FILE *ira_dump_file; /* Typedefs for pointers to allocno live range, allocno, and copy of allocnos. */ -typedef struct ira_allocno_live_range *allocno_live_range_t; +typedef struct live_range *live_range_t; typedef struct ira_allocno *ira_allocno_t; typedef struct ira_allocno_copy *ira_copy_t; @@ -196,7 +196,7 @@ extern ira_loop_tree_node_t ira_loop_nod conflicts for other allocnos (e.g. to assign stack memory slot) we use the live ranges. If the live ranges of two allocnos are intersected, the allocnos are in conflict. */ -struct ira_allocno_live_range +struct live_range { /* Allocno whose live range is described by given structure. */ ira_allocno_t allocno; @@ -204,9 +204,9 @@ struct ira_allocno_live_range int start, finish; /* Next structure describing program points where the allocno lives. */ - allocno_live_range_t next; + live_range_t next; /* Pointer to structures with the same start/finish. */ - allocno_live_range_t start_next, finish_next; + live_range_t start_next, finish_next; }; /* Program points are enumerated by numbers from range @@ -220,7 +220,7 @@ extern int ira_max_point; /* Arrays of size IRA_MAX_POINT mapping a program point to the allocno live ranges with given start/finish point. */ -extern allocno_live_range_t *ira_start_point_ranges, *ira_finish_point_ranges; +extern live_range_t *ira_start_point_ranges, *ira_finish_point_ranges; /* A structure representing an allocno (allocation entity). Allocno represents a pseudo-register in an allocation region. If @@ -305,7 +305,7 @@ struct ira_allocno allocno lives. We always maintain the list in such way that *the ranges in the list are not intersected and ordered by decreasing their program points*. */ - allocno_live_range_t live_ranges; + live_range_t live_ranges; /* Before building conflicts the two member values are correspondingly minimal and maximal points of the accumulated allocno live ranges. After building conflicts the values are @@ -845,16 +845,13 @@ extern void ira_allocate_allocno_conflic extern void ira_allocate_allocno_conflicts (ira_allocno_t, int); extern void ira_add_allocno_conflict (ira_allocno_t, ira_allocno_t); extern void ira_print_expanded_allocno (ira_allocno_t); -extern allocno_live_range_t ira_create_allocno_live_range - (ira_allocno_t, int, int, allocno_live_range_t); -extern allocno_live_range_t ira_copy_allocno_live_range_list - (allocno_live_range_t); -extern allocno_live_range_t ira_merge_allocno_live_ranges - (allocno_live_range_t, allocno_live_range_t); -extern bool ira_allocno_live_ranges_intersect_p (allocno_live_range_t, - allocno_live_range_t); -extern void ira_finish_allocno_live_range (allocno_live_range_t); -extern void ira_finish_allocno_live_range_list (allocno_live_range_t); +extern live_range_t ira_create_allocno_live_range (ira_allocno_t, int, int, + live_range_t); +extern live_range_t ira_copy_allocno_live_range_list (live_range_t); +extern live_range_t ira_merge_allocno_live_ranges (live_range_t, live_range_t); +extern bool ira_allocno_live_ranges_intersect_p (live_range_t, live_range_t); +extern void ira_finish_allocno_live_range (live_range_t); +extern void ira_finish_allocno_live_range_list (live_range_t); extern void ira_free_allocno_updated_costs (ira_allocno_t); extern ira_copy_t ira_create_copy (ira_allocno_t, ira_allocno_t, int, bool, rtx, ira_loop_tree_node_t); @@ -881,8 +878,8 @@ extern void ira_tune_allocno_costs_and_c /* ira-lives.c */ extern void ira_rebuild_start_finish_chains (void); -extern void ira_print_live_range_list (FILE *, allocno_live_range_t); -extern void ira_debug_live_range_list (allocno_live_range_t); +extern void ira_print_live_range_list (FILE *, live_range_t); +extern void ira_debug_live_range_list (live_range_t); extern void ira_debug_allocno_live_ranges (ira_allocno_t); extern void ira_debug_live_ranges (void); extern void ira_create_allocno_live_ranges (void); Index: gcc/ira-lives.c =================================================================== --- gcc.orig/ira-lives.c +++ gcc/ira-lives.c @@ -54,7 +54,7 @@ int ira_max_point; /* Arrays of size IRA_MAX_POINT mapping a program point to the allocno live ranges with given start/finish point. */ -allocno_live_range_t *ira_start_point_ranges, *ira_finish_point_ranges; +live_range_t *ira_start_point_ranges, *ira_finish_point_ranges; /* Number of the current program point. */ static int curr_point; @@ -112,7 +112,7 @@ make_hard_regno_dead (int regno) static void make_allocno_born (ira_allocno_t a) { - allocno_live_range_t p = ALLOCNO_LIVE_RANGES (a); + live_range_t p = ALLOCNO_LIVE_RANGES (a); sparseset_set_bit (allocnos_live, ALLOCNO_NUM (a)); IOR_HARD_REG_SET (ALLOCNO_CONFLICT_HARD_REGS (a), hard_regs_live); @@ -131,7 +131,7 @@ update_allocno_pressure_excess_length (i { int start, i; enum reg_class cover_class, cl; - allocno_live_range_t p; + live_range_t p; cover_class = ALLOCNO_COVER_CLASS (a); for (i = 0; @@ -153,7 +153,7 @@ update_allocno_pressure_excess_length (i static void make_allocno_dead (ira_allocno_t a) { - allocno_live_range_t p; + live_range_t p; p = ALLOCNO_LIVE_RANGES (a); ira_assert (p != NULL); @@ -1140,18 +1140,18 @@ create_start_finish_chains (void) { ira_allocno_t a; ira_allocno_iterator ai; - allocno_live_range_t r; + live_range_t r; ira_start_point_ranges - = (allocno_live_range_t *) ira_allocate (ira_max_point - * sizeof (allocno_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 (allocno_live_range_t)); + ira_max_point * sizeof (live_range_t)); ira_finish_point_ranges - = (allocno_live_range_t *) ira_allocate (ira_max_point - * sizeof (allocno_live_range_t)); + = (live_range_t *) ira_allocate (ira_max_point + * sizeof (live_range_t)); memset (ira_finish_point_ranges, 0, - ira_max_point * sizeof (allocno_live_range_t)); + ira_max_point * sizeof (live_range_t)); FOR_EACH_ALLOCNO (a, ai) { for (r = ALLOCNO_LIVE_RANGES (a); r != NULL; r = r->next) @@ -1185,7 +1185,7 @@ remove_some_program_points_and_update_li int *map; ira_allocno_t a; ira_allocno_iterator ai; - allocno_live_range_t r; + live_range_t r; bitmap born_or_died; bitmap_iterator bi; @@ -1223,7 +1223,7 @@ remove_some_program_points_and_update_li /* Print live ranges R to file F. */ void -ira_print_live_range_list (FILE *f, allocno_live_range_t r) +ira_print_live_range_list (FILE *f, live_range_t r) { for (; r != NULL; r = r->next) fprintf (f, " [%d..%d]", r->start, r->finish); @@ -1232,7 +1232,7 @@ ira_print_live_range_list (FILE *f, allo /* Print live ranges R to stderr. */ void -ira_debug_live_range_list (allocno_live_range_t r) +ira_debug_live_range_list (live_range_t r) { ira_print_live_range_list (stderr, r); }