Patch 8/9: track live ranges for objects

Index: gcc/ira-build.c
===================================================================
--- gcc.orig/ira-build.c
+++ gcc/ira-build.c
@@ -439,6 +439,7 @@  ira_create_object (ira_allocno_t a)
 			  reg_class_contents[cover_class]);
   OBJECT_MIN (obj) = INT_MAX;
   OBJECT_MAX (obj) = -1;
+  OBJECT_LIVE_RANGES (obj) = NULL;
 
   VEC_safe_push (ira_object_t, heap, ira_object_id_map_vec, obj);
   ira_object_id_map
@@ -508,7 +509,6 @@  ira_create_allocno (int regno, bool cap_
   ALLOCNO_PREV_BUCKET_ALLOCNO (a) = NULL;
   ALLOCNO_FIRST_COALESCED_ALLOCNO (a) = a;
   ALLOCNO_NEXT_COALESCED_ALLOCNO (a) = a;
-  ALLOCNO_LIVE_RANGES (a) = NULL;
 
   VEC_safe_push (ira_allocno_t, heap, allocno_vec, a);
   ira_allocnos = VEC_address (ira_allocno_t, allocno_vec);
@@ -850,13 +850,13 @@  create_cap_allocno (ira_allocno_t a)
 
 /* Create and return allocno live range with given attributes.  */
 live_range_t
-ira_create_allocno_live_range (ira_allocno_t a, int start, int finish,
-			       live_range_t next)
+ira_create_live_range (ira_object_t obj, int start, int finish,
+		       live_range_t next)
 {
   live_range_t p;
 
   p = (live_range_t) pool_alloc (live_range_pool);
-  p->allocno = a;
+  p->object = obj;
   p->start = start;
   p->finish = finish;
   p->next = next;
@@ -865,7 +865,7 @@  ira_create_allocno_live_range (ira_alloc
 
 /* Copy allocno live range R and return the result.  */
 static live_range_t
-copy_allocno_live_range (live_range_t r)
+copy_live_range (live_range_t r)
 {
   live_range_t p;
 
@@ -877,7 +877,7 @@  copy_allocno_live_range (live_range_t r)
 /* Copy allocno live range list given by its head R and return the
    result.  */
 live_range_t
-ira_copy_allocno_live_range_list (live_range_t r)
+ira_copy_live_range_list (live_range_t r)
 {
   live_range_t p, first, last;
 
@@ -885,7 +885,7 @@  ira_copy_allocno_live_range_list (live_r
     return NULL;
   for (first = last = NULL; r != NULL; r = r->next)
     {
-      p = copy_allocno_live_range (r);
+      p = copy_live_range (r);
       if (first == NULL)
 	first = p;
       else
@@ -899,7 +899,7 @@  ira_copy_allocno_live_range_list (live_r
    maintains the order of ranges and tries to minimize number of the
    result ranges.  */
 live_range_t
-ira_merge_allocno_live_ranges (live_range_t r1, live_range_t r2)
+ira_merge_live_ranges (live_range_t r1, live_range_t r2)
 {
   live_range_t first, last, temp;
 
@@ -923,7 +923,7 @@  ira_merge_allocno_live_ranges (live_rang
 	    r1->finish = r2->finish;
 	  temp = r2;
 	  r2 = r2->next;
-	  ira_finish_allocno_live_range (temp);
+	  ira_finish_live_range (temp);
 	  if (r2 == NULL)
 	    {
 	      /* To try to merge with subsequent ranges in r1.  */
@@ -975,7 +975,7 @@  ira_merge_allocno_live_ranges (live_rang
 
 /* Return TRUE if live ranges R1 and R2 intersect.  */
 bool
-ira_allocno_live_ranges_intersect_p (live_range_t r1, live_range_t r2)
+ira_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)
@@ -992,21 +992,21 @@  ira_allocno_live_ranges_intersect_p (liv
 
 /* Free allocno live range R.  */
 void
-ira_finish_allocno_live_range (live_range_t r)
+ira_finish_live_range (live_range_t r)
 {
   pool_free (live_range_pool, r);
 }
 
 /* Free list of allocno live ranges starting with R.  */
 void
-ira_finish_allocno_live_range_list (live_range_t r)
+ira_finish_live_range_list (live_range_t r)
 {
   live_range_t next_r;
 
   for (; r != NULL; r = next_r)
     {
       next_r = r->next;
-      ira_finish_allocno_live_range (r);
+      ira_finish_live_range (r);
     }
 }
 
@@ -1033,6 +1033,12 @@  finish_allocno (ira_allocno_t a)
   enum reg_class cover_class = ALLOCNO_COVER_CLASS (a);
   ira_object_t obj = ALLOCNO_OBJECT (a);
 
+  ira_finish_live_range_list (OBJECT_LIVE_RANGES (obj));
+  ira_object_id_map[OBJECT_CONFLICT_ID (obj)] = NULL;
+  if (OBJECT_CONFLICT_ARRAY (obj) != NULL)
+    ira_free (OBJECT_CONFLICT_ARRAY (obj));
+  pool_free (object_pool, obj);
+
   ira_allocnos[ALLOCNO_NUM (a)] = NULL;
   if (ALLOCNO_HARD_REG_COSTS (a) != NULL)
     ira_free_cost_vector (ALLOCNO_HARD_REG_COSTS (a), cover_class);
@@ -1043,13 +1049,7 @@  finish_allocno (ira_allocno_t a)
   if (ALLOCNO_UPDATED_CONFLICT_HARD_REG_COSTS (a) != NULL)
     ira_free_cost_vector (ALLOCNO_UPDATED_CONFLICT_HARD_REG_COSTS (a),
 			  cover_class);
-  ira_finish_allocno_live_range_list (ALLOCNO_LIVE_RANGES (a));
   pool_free (allocno_pool, a);
-
-  ira_object_id_map[OBJECT_CONFLICT_ID (obj)] = NULL;
-  if (OBJECT_CONFLICT_ARRAY (obj) != NULL)
-    ira_free (OBJECT_CONFLICT_ARRAY (obj));
-  pool_free (object_pool, obj);
 }
 
 /* Free the memory allocated for all allocnos.  */
@@ -1695,19 +1695,21 @@  create_allocnos (void)
    will hardly improve the result.  As a result we speed up regional
    register allocation.  */
 
-/* The function changes allocno in range list given by R onto A.  */
+/* The function changes the object in range list given by R to OBJ.  */
 static void
-change_allocno_in_range_list (live_range_t r, ira_allocno_t a)
+change_object_in_range_list (live_range_t r, ira_object_t obj)
 {
   for (; r != NULL; r = r->next)
-    r->allocno = a;
+    r->object = obj;
 }
 
 /* Move all live ranges associated with allocno A to allocno OTHER_A.  */
 static void
 move_allocno_live_ranges (ira_allocno_t from, ira_allocno_t to)
 {
-  live_range_t lr = ALLOCNO_LIVE_RANGES (from);
+  ira_object_t from_obj = ALLOCNO_OBJECT (from);
+  ira_object_t to_obj = ALLOCNO_OBJECT (to);
+  live_range_t lr = OBJECT_LIVE_RANGES (from_obj);
 
   if (internal_flag_ira_verbose > 4 && ira_dump_file != NULL)
     {
@@ -1717,17 +1719,19 @@  move_allocno_live_ranges (ira_allocno_t 
 	       ALLOCNO_NUM (to), ALLOCNO_REGNO (to));
       ira_print_live_range_list (ira_dump_file, lr);
     }
-  change_allocno_in_range_list (lr, to);
-  ALLOCNO_LIVE_RANGES (to)
-    = ira_merge_allocno_live_ranges (lr, ALLOCNO_LIVE_RANGES (to));
-  ALLOCNO_LIVE_RANGES (from) = NULL;
+  change_object_in_range_list (lr, to_obj);
+  OBJECT_LIVE_RANGES (to_obj)
+    = ira_merge_live_ranges (lr, OBJECT_LIVE_RANGES (to_obj));
+  OBJECT_LIVE_RANGES (from_obj) = NULL;
 }
 
 /* Copy all live ranges associated with allocno A to allocno OTHER_A.  */
 static void
 copy_allocno_live_ranges (ira_allocno_t from, ira_allocno_t to)
 {
-  live_range_t lr = ALLOCNO_LIVE_RANGES (from);
+  ira_object_t from_obj = ALLOCNO_OBJECT (from);
+  ira_object_t to_obj = ALLOCNO_OBJECT (to);
+  live_range_t lr = OBJECT_LIVE_RANGES (from_obj);
 
   if (internal_flag_ira_verbose > 4 && ira_dump_file != NULL)
     {
@@ -1737,10 +1741,10 @@  copy_allocno_live_ranges (ira_allocno_t 
 	       ALLOCNO_NUM (to), ALLOCNO_REGNO (to));
       ira_print_live_range_list (ira_dump_file, lr);
     }
-  lr = ira_copy_allocno_live_range_list (lr);
-  change_allocno_in_range_list (lr, to);
-  ALLOCNO_LIVE_RANGES (to)
-    = ira_merge_allocno_live_ranges (lr, ALLOCNO_LIVE_RANGES (to));
+  lr = ira_copy_live_range_list (lr);
+  change_object_in_range_list (lr, to_obj);
+  OBJECT_LIVE_RANGES (to_obj)
+    = ira_merge_live_ranges (lr, OBJECT_LIVE_RANGES (to_obj));
 }
 
 /* Return TRUE if NODE represents a loop with low register
@@ -2200,20 +2204,22 @@  update_bad_spill_attribute (void)
     }
   FOR_EACH_ALLOCNO (a, ai)
     {
+      ira_object_t obj = ALLOCNO_OBJECT (a);
       cover_class = ALLOCNO_COVER_CLASS (a);
       if (cover_class == NO_REGS)
 	continue;
-      for (r = ALLOCNO_LIVE_RANGES (a); r != NULL; r = r->next)
+      for (r = OBJECT_LIVE_RANGES (obj); r != NULL; r = r->next)
 	bitmap_set_bit (&dead_points[cover_class], r->finish);
     }
   FOR_EACH_ALLOCNO (a, ai)
     {
+      ira_object_t obj = ALLOCNO_OBJECT (a);
       cover_class = ALLOCNO_COVER_CLASS (a);
       if (cover_class == NO_REGS)
 	continue;
       if (! ALLOCNO_BAD_SPILL_P (a))
 	continue;
-      for (r = ALLOCNO_LIVE_RANGES (a); r != NULL; r = r->next)
+      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))
@@ -2246,7 +2252,7 @@  setup_min_max_allocno_live_range_point (
   FOR_EACH_ALLOCNO (a, ai)
     {
       ira_object_t obj = ALLOCNO_OBJECT (a);
-      r = ALLOCNO_LIVE_RANGES (a);
+      r = OBJECT_LIVE_RANGES (obj);
       if (r == NULL)
 	continue;
       OBJECT_MAX (obj) = r->finish;
@@ -2544,7 +2550,7 @@  copy_info_to_removed_store_destinations 
 void
 ira_flattening (int max_regno_before_emit, int ira_max_point_before_emit)
 {
-  int i, j, num;
+  int i, j;
   bool keep_p;
   int hard_regs_num;
   bool new_pseudos_p, merged_p, mem_dest_p;
@@ -2556,7 +2562,6 @@  ira_flattening (int max_regno_before_emi
   live_range_t r;
   ira_allocno_iterator ai;
   ira_copy_iterator ci;
-  sparseset allocnos_live;
 
   regno_top_level_allocno_map
     = (ira_allocno_t *) ira_allocate (max_reg_num () * sizeof (ira_allocno_t));
@@ -2652,48 +2657,48 @@  ira_flattening (int max_regno_before_emi
     ira_rebuild_start_finish_chains ();
   if (new_pseudos_p)
     {
+      sparseset objects_live;
+
       /* Rebuild conflicts.  */
       FOR_EACH_ALLOCNO (a, ai)
 	{
+	  ira_object_t obj = ALLOCNO_OBJECT (a);
 	  if (a != regno_top_level_allocno_map[REGNO (ALLOCNO_REG (a))]
 	      || ALLOCNO_CAP_MEMBER (a) != NULL)
 	    continue;
-	  for (r = ALLOCNO_LIVE_RANGES (a); r != NULL; r = r->next)
-	    ira_assert (r->allocno == a);
-	  clear_conflicts (ALLOCNO_OBJECT (a));
+	  for (r = OBJECT_LIVE_RANGES (obj); r != NULL; r = r->next)
+	    ira_assert (r->object == obj);
+	  clear_conflicts (obj);
 	}
-      allocnos_live = sparseset_alloc (ira_allocnos_num);
+      objects_live = sparseset_alloc (ira_objects_num);
       for (i = 0; i < ira_max_point; i++)
 	{
 	  for (r = ira_start_point_ranges[i]; r != NULL; r = r->start_next)
 	    {
-	      a = r->allocno;
+	      ira_object_t obj = r->object;
+	      a = OBJECT_ALLOCNO (obj);
 	      if (a != regno_top_level_allocno_map[REGNO (ALLOCNO_REG (a))]
 		  || ALLOCNO_CAP_MEMBER (a) != NULL)
 		continue;
-	      num = ALLOCNO_NUM (a);
 	      cover_class = ALLOCNO_COVER_CLASS (a);
-	      sparseset_set_bit (allocnos_live, num);
-	      EXECUTE_IF_SET_IN_SPARSESET (allocnos_live, n)
+	      sparseset_set_bit (objects_live, OBJECT_CONFLICT_ID (obj));
+	      EXECUTE_IF_SET_IN_SPARSESET (objects_live, n)
 		{
-		  ira_allocno_t live_a = ira_allocnos[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][ALLOCNO_COVER_CLASS (live_a)]
+		  if (ira_reg_classes_intersect_p[cover_class][live_cover]
 		      /* Don't set up conflict for the allocno with itself.  */
-		      && num != (int) n)
-		    {
-		      ira_object_t obj = ALLOCNO_OBJECT (a);
-		      ira_object_t live_obj = ALLOCNO_OBJECT (live_a);
-		      ira_add_conflict (obj, live_obj);
-		    }
+		      && live_a != a)
+		    ira_add_conflict (obj, live_obj);
 		}
 	    }
 
 	  for (r = ira_finish_point_ranges[i]; r != NULL; r = r->finish_next)
-	    sparseset_clear_bit (allocnos_live, ALLOCNO_NUM (r->allocno));
+	    sparseset_clear_bit (objects_live, OBJECT_CONFLICT_ID (r->object));
 	}
-      sparseset_free (allocnos_live);
+      sparseset_free (objects_live);
       compress_conflict_vecs ();
     }
   /* Mark some copies for removing and change allocnos in the rest
@@ -2939,7 +2944,8 @@  ira_build (bool loops_p)
 	}
       nr = 0;
       FOR_EACH_ALLOCNO (a, ai)
-	for (r = ALLOCNO_LIVE_RANGES (a); r != NULL; r = r->next)
+	for (r = OBJECT_LIVE_RANGES (ALLOCNO_OBJECT (a)); r != NULL;
+	     r = r->next)
 	  nr++;
       fprintf (ira_dump_file, "  regions=%d, blocks=%d, points=%d\n",
 	       VEC_length (loop_p, ira_loops.larray), n_basic_blocks,
Index: gcc/ira-color.c
===================================================================
--- gcc.orig/ira-color.c
+++ gcc/ira-color.c
@@ -93,14 +93,16 @@  static VEC(ira_allocno_t,heap) *removed_
 static bool
 allocnos_have_intersected_live_ranges_p (ira_allocno_t a1, ira_allocno_t a2)
 {
+  ira_object_t obj1 = ALLOCNO_OBJECT (a1);
+  ira_object_t obj2 = ALLOCNO_OBJECT (a2);
   if (a1 == a2)
     return false;
   if (ALLOCNO_REG (a1) != NULL && ALLOCNO_REG (a2) != NULL
       && (ORIGINAL_REGNO (ALLOCNO_REG (a1))
 	  == ORIGINAL_REGNO (ALLOCNO_REG (a2))))
     return false;
-  return ira_allocno_live_ranges_intersect_p (ALLOCNO_LIVE_RANGES (a1),
-					      ALLOCNO_LIVE_RANGES (a2));
+  return ira_live_ranges_intersect_p (OBJECT_LIVE_RANGES (obj1),
+				      OBJECT_LIVE_RANGES (obj2));
 }
 
 #ifdef ENABLE_IRA_CHECKING
@@ -2510,8 +2512,9 @@  slot_coalesced_allocno_live_ranges_inter
   for (a = ALLOCNO_NEXT_COALESCED_ALLOCNO (allocno);;
        a = ALLOCNO_NEXT_COALESCED_ALLOCNO (a))
     {
-      if (ira_allocno_live_ranges_intersect_p
-	  (slot_coalesced_allocnos_live_ranges[n], ALLOCNO_LIVE_RANGES (a)))
+      ira_object_t obj = ALLOCNO_OBJECT (a);
+      if (ira_live_ranges_intersect_p
+	  (slot_coalesced_allocnos_live_ranges[n], OBJECT_LIVE_RANGES (obj)))
 	return true;
       if (a == allocno)
 	break;
@@ -2532,9 +2535,10 @@  setup_slot_coalesced_allocno_live_ranges
   for (a = ALLOCNO_NEXT_COALESCED_ALLOCNO (allocno);;
        a = ALLOCNO_NEXT_COALESCED_ALLOCNO (a))
     {
-      r = ira_copy_allocno_live_range_list (ALLOCNO_LIVE_RANGES (a));
+      ira_object_t obj = ALLOCNO_OBJECT (a);
+      r = ira_copy_live_range_list (OBJECT_LIVE_RANGES (obj));
       slot_coalesced_allocnos_live_ranges[n]
-	= ira_merge_allocno_live_ranges
+	= ira_merge_live_ranges
 	  (slot_coalesced_allocnos_live_ranges[n], r);
       if (a == allocno)
 	break;
@@ -2605,8 +2609,7 @@  coalesce_spill_slots (ira_allocno_t *spi
 	}
     }
   for (i = 0; i < ira_allocnos_num; i++)
-    ira_finish_allocno_live_range_list
-      (slot_coalesced_allocnos_live_ranges[i]);
+    ira_finish_live_range_list (slot_coalesced_allocnos_live_ranges[i]);
   ira_free (slot_coalesced_allocnos_live_ranges);
   return merged_p;
 }
@@ -3270,7 +3273,7 @@  fast_allocation (void)
       a = sorted_allocnos[i];
       obj = ALLOCNO_OBJECT (a);
       COPY_HARD_REG_SET (conflict_hard_regs, OBJECT_CONFLICT_HARD_REGS (obj));
-      for (r = ALLOCNO_LIVE_RANGES (a); r != NULL; r = r->next)
+      for (r = OBJECT_LIVE_RANGES (obj); r != NULL; r = r->next)
 	for (j =  r->start; j <= r->finish; j++)
 	  IOR_HARD_REG_SET (conflict_hard_regs, used_hard_regs[j]);
       cover_class = ALLOCNO_COVER_CLASS (a);
@@ -3297,7 +3300,7 @@  fast_allocation (void)
 		  (prohibited_class_mode_regs[cover_class][mode], hard_regno)))
 	    continue;
 	  ALLOCNO_HARD_REGNO (a) = hard_regno;
-	  for (r = ALLOCNO_LIVE_RANGES (a); r != NULL; r = r->next)
+	  for (r = OBJECT_LIVE_RANGES (obj); r != NULL; r = r->next)
 	    for (k = r->start; k <= r->finish; k++)
 	      IOR_HARD_REG_SET (used_hard_regs[k],
 				ira_reg_mode_hard_regset[hard_regno][mode]);
Index: gcc/ira-conflicts.c
===================================================================
--- gcc.orig/ira-conflicts.c
+++ gcc/ira-conflicts.c
@@ -132,8 +132,8 @@  build_conflict_bit_table (void)
     {
       for (r = ira_start_point_ranges[i]; r != NULL; r = r->start_next)
 	{
-	  ira_allocno_t allocno = r->allocno;
-	  ira_object_t obj = ALLOCNO_OBJECT (allocno);
+	  ira_object_t obj = r->object;
+	  ira_allocno_t allocno = OBJECT_ALLOCNO (obj);
 	  int id = OBJECT_CONFLICT_ID (obj);
 
 	  cover_class = ALLOCNO_COVER_CLASS (allocno);
@@ -160,8 +160,7 @@  build_conflict_bit_table (void)
 
       for (r = ira_finish_point_ranges[i]; r != NULL; r = r->finish_next)
 	{
-	  ira_allocno_t allocno = r->allocno;
-	  ira_object_t obj = ALLOCNO_OBJECT (allocno);
+	  ira_object_t obj = r->object;
 	  sparseset_clear_bit (objects_live, OBJECT_CONFLICT_ID (obj));
 	}
     }
Index: gcc/ira-emit.c
===================================================================
--- gcc.orig/ira-emit.c
+++ gcc/ira-emit.c
@@ -960,11 +960,11 @@  add_range_and_copies_from_move_list (mov
 		 cp->num, ALLOCNO_NUM (cp->first),
 		 REGNO (ALLOCNO_REG (cp->first)), ALLOCNO_NUM (cp->second),
 		 REGNO (ALLOCNO_REG (cp->second)));
-      r = ALLOCNO_LIVE_RANGES (from);
+      r = OBJECT_LIVE_RANGES (from_obj);
       if (r == NULL || r->finish >= 0)
 	{
-	  ALLOCNO_LIVE_RANGES (from)
-	    = ira_create_allocno_live_range (from, start, ira_max_point, r);
+	  OBJECT_LIVE_RANGES (from_obj)
+	    = ira_create_live_range (from_obj, start, ira_max_point, r);
 	  if (internal_flag_ira_verbose > 2 && ira_dump_file != NULL)
 	    fprintf (ira_dump_file,
 		     "    Adding range [%d..%d] to allocno a%dr%d\n",
@@ -981,14 +981,15 @@  add_range_and_copies_from_move_list (mov
 		     REGNO (ALLOCNO_REG (from)));
 	}
       ira_max_point++;
-      ALLOCNO_LIVE_RANGES (to)
-	= ira_create_allocno_live_range (to, ira_max_point, -1,
-					 ALLOCNO_LIVE_RANGES (to));
+      OBJECT_LIVE_RANGES (to_obj)
+	= ira_create_live_range (to_obj, ira_max_point, -1,
+				 OBJECT_LIVE_RANGES (to_obj));
       ira_max_point++;
     }
   for (move = list; move != NULL; move = move->next)
     {
-      r = ALLOCNO_LIVE_RANGES (move->to);
+      ira_object_t to_obj = ALLOCNO_OBJECT (move->to);
+      r = OBJECT_LIVE_RANGES (to_obj);
       if (r->finish < 0)
 	{
 	  r->finish = ira_max_point - 1;
@@ -1002,12 +1003,15 @@  add_range_and_copies_from_move_list (mov
   EXECUTE_IF_SET_IN_BITMAP (live_through, FIRST_PSEUDO_REGISTER, regno, bi)
     {
       ira_allocno_t to;
+      ira_object_t obj;
       a = node->regno_allocno_map[regno];
-      if ((to = ALLOCNO_MEM_OPTIMIZED_DEST (a)) != NULL)
+      to = ALLOCNO_MEM_OPTIMIZED_DEST (a);
+      if (to != NULL)
 	a = to;
-      ALLOCNO_LIVE_RANGES (a)
-	= ira_create_allocno_live_range (a, start, ira_max_point - 1,
-					 ALLOCNO_LIVE_RANGES (a));
+      obj = ALLOCNO_OBJECT (a);
+      OBJECT_LIVE_RANGES (obj)
+	= ira_create_live_range (obj, start, ira_max_point - 1,
+				 OBJECT_LIVE_RANGES (obj));
       if (internal_flag_ira_verbose > 2 && ira_dump_file != NULL)
 	fprintf
 	  (ira_dump_file,
Index: gcc/ira-int.h
===================================================================
--- gcc.orig/ira-int.h
+++ gcc/ira-int.h
@@ -202,7 +202,7 @@  extern ira_loop_tree_node_t ira_loop_nod
 struct live_range
 {
   /* Allocno whose live range is described by given structure.  */
-  ira_allocno_t allocno;
+  ira_object_t object;
   /* Program point range.  */
   int start, finish;
   /* Next structure describing program points where the allocno
@@ -236,7 +236,12 @@  struct ira_object
      otherwise.  Only objects belonging to allocnos with the
      same cover class are in the vector or in the bit vector.  */
   void *conflicts_array;
-  /* Allocated size of the previous array.  */
+  /* Pointer to structures describing at what program point the
+     object 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*.  */
+  live_range_t live_ranges;
+  /* Allocated size of the conflicts array.  */
   unsigned int conflicts_array_size;
   /* A unique number for every instance of this structure which is used
      to represent it in conflict bit vectors.  */
@@ -341,11 +346,6 @@  struct ira_allocno
      list is chained by NEXT_COALESCED_ALLOCNO.  */
   ira_allocno_t first_coalesced_allocno;
   ira_allocno_t next_coalesced_allocno;
-  /* Pointer to structures describing at what program point the
-     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*.  */
-  live_range_t live_ranges;
   /* Pointer to a structure describing conflict information about this
      allocno.  */
   ira_object_t object;
@@ -483,7 +483,6 @@  struct ira_allocno
 #define ALLOCNO_TEMP(A) ((A)->temp)
 #define ALLOCNO_FIRST_COALESCED_ALLOCNO(A) ((A)->first_coalesced_allocno)
 #define ALLOCNO_NEXT_COALESCED_ALLOCNO(A) ((A)->next_coalesced_allocno)
-#define ALLOCNO_LIVE_RANGES(A) ((A)->live_ranges)
 #define ALLOCNO_OBJECT(A) ((A)->object)
 
 #define OBJECT_ALLOCNO(C) ((C)->allocno)
@@ -498,6 +497,7 @@  struct ira_allocno
 #define OBJECT_MIN(C) ((C)->min)
 #define OBJECT_MAX(C) ((C)->max)
 #define OBJECT_CONFLICT_ID(C) ((C)->id)
+#define OBJECT_LIVE_RANGES(C) ((C)->live_ranges)
 
 /* Map regno -> allocnos with given regno (see comments for
    allocno member `next_regno_allocno').  */
@@ -864,13 +864,13 @@  extern bool ira_conflict_vector_profitab
 extern void ira_allocate_conflict_vec (ira_object_t, int);
 extern void ira_allocate_object_conflicts (ira_object_t, int);
 extern void ira_print_expanded_allocno (ira_allocno_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 live_range_t ira_create_live_range (ira_object_t, int, int,
+					   live_range_t);
+extern live_range_t ira_copy_live_range_list (live_range_t);
+extern live_range_t ira_merge_live_ranges (live_range_t, live_range_t);
+extern bool ira_live_ranges_intersect_p (live_range_t, live_range_t);
+extern void ira_finish_live_range (live_range_t);
+extern void ira_finish_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);
Index: gcc/ira-lives.c
===================================================================
--- gcc.orig/ira-lives.c
+++ gcc/ira-lives.c
@@ -112,8 +112,8 @@  make_hard_regno_dead (int regno)
 static void
 make_allocno_born (ira_allocno_t a)
 {
-  live_range_t p = ALLOCNO_LIVE_RANGES (a);
   ira_object_t obj = ALLOCNO_OBJECT (a);
+  live_range_t p = OBJECT_LIVE_RANGES (obj);
 
   sparseset_set_bit (allocnos_live, ALLOCNO_NUM (a));
   IOR_HARD_REG_SET (OBJECT_CONFLICT_HARD_REGS (obj), hard_regs_live);
@@ -121,9 +121,8 @@  make_allocno_born (ira_allocno_t a)
 
   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));
+    OBJECT_LIVE_RANGES (obj)
+      = ira_create_live_range (obj, curr_point, -1, p);
 }
 
 /* Update ALLOCNO_EXCESS_PRESSURE_POINTS_NUM for allocno A.  */
@@ -139,9 +138,10 @@  update_allocno_pressure_excess_length (i
        (cl = ira_reg_class_super_classes[cover_class][i]) != LIM_REG_CLASSES;
        i++)
     {
+      ira_object_t obj = ALLOCNO_OBJECT (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);
@@ -154,9 +154,9 @@  update_allocno_pressure_excess_length (i
 static void
 make_allocno_dead (ira_allocno_t a)
 {
-  live_range_t p;
+  ira_object_t obj = ALLOCNO_OBJECT (a);
+  live_range_t p = OBJECT_LIVE_RANGES (obj);
 
-  p = ALLOCNO_LIVE_RANGES (a);
   ira_assert (p != NULL);
   p->finish = curr_point;
   update_allocno_pressure_excess_length (a);
@@ -1159,7 +1159,8 @@  create_start_finish_chains (void)
 	  ira_max_point * sizeof (live_range_t));
   FOR_EACH_ALLOCNO (a, ai)
     {
-      for (r = ALLOCNO_LIVE_RANGES (a); r != NULL; r = r->next)
+      ira_object_t obj = ALLOCNO_OBJECT (a);
+      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;
@@ -1188,22 +1189,21 @@  remove_some_program_points_and_update_li
   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);
+  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)
@@ -1215,14 +1215,13 @@  remove_some_program_points_and_update_li
     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);
 }
 
@@ -1246,8 +1245,9 @@  ira_debug_live_range_list (live_range_t 
 static void
 print_allocno_live_ranges (FILE *f, ira_allocno_t a)
 {
+  ira_object_t obj = ALLOCNO_OBJECT (a);
   fprintf (f, " a%d(r%d):", ALLOCNO_NUM (a), ALLOCNO_REGNO (a));
-  ira_print_live_range_list (f, ALLOCNO_LIVE_RANGES (a));
+  ira_print_live_range_list (f, OBJECT_LIVE_RANGES (obj));
 }
 
 /* Print live ranges of allocno A to stderr.  */