Patch 6/9: remove "allocno" from live_range_t

[Bernd Schmidt <bernds@codesourcery.com>]

[-- Attachment #1: Type: text/plain, Size: 0 bytes --]



[-- Attachment #2: live_range_t.diff --]
[-- Type: text/plain, Size: 16520 bytes --]

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)
 
 \f
 
-/* 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);
 }
 
 \f
@@ -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);
 }