* ira-build.c (ira_create_object): New arg SUBWORD; all callers changed.

	Initialize OBJECT_SUBWORD.
	(ira_create_allocno): Clear ALLOCNO_NUM_OBJECTS.
	(ira_create_allocno_objects): Renamed from ira_create_allocno_object;
	all callers changed.
	(merge_hard_reg_conflicts): Iterate over allocno subobjects.
	(finish_allocno): Likewise.
	(move_allocno_live_ranges, copy_allocno_live_ranges): Likewise.
	(remove_low_level_allocnos): Likewise.
	(update_bad_spill_attribute): Likewise.
	(setup_min_max_allocno_live_range_point): Likewise.
	(sort_conflict_id_map): Likewise.
	(ira_flattening): Likewise.  Use ior_hard_reg_conflicts.
	(ior_hard_reg_conflicts): New function.
	(ior_allocate_object_conflicts): Renamed first argument to OBJ.
	(compress_conflict_vecs): Iterate over objects, not allocnos.
	(ira_add_live_range_to_object): New function.
	(object_range_compare_func): Renamed from allocno_range_compare_func.
	All callers changed.
	(setup_min_max_conflict_allocno_ids): For allocnos with multiple
	subobjects, widen the min/max range of the lowest-order object to
	potentially include all other such low-order objects.
	* ira.c (ira_bad_reload_regno_1): Iterate over allocno subobjects.
	(check_allocation): Likewise.  Use more fine-grained tests for register
	conflicts.
	* ira-color.c (allocnos_have_intersected_live_ranges_p): Iterate over
	allocno subobjects.
	(assign_hard_reg): Keep multiple sets of conflicts.  Make finer-grained
	choices about which bits to set in each set.  Don't use
	ira_hard_reg_not_in_set_p, perform a more elaborate test for conflicts
	using the multiple sets we computed.
	(push_allocno_to_stack): Iterate over allocno subobjects.
	(all_conflicting_hard_regs_coalesced): New static function.
	(setup_allocno_available_regs_num): Use it.
	(setup_allocno_left_conflicts_size): Likewise.  Iterate over allocno
	subobjects.
	(coalesced_allocno_conflict): Test subobject 0 in each allocno.
	(setup_allocno_priorities): Divide ALLOCNO_EXCESS_PRESSURE_POINTS_NUM
	by ALLOCNO_NUM_OBJECTS.
	(calculate_spill_cost): Likewise.
	(color_pass): Express if statement in a more normal way.
	(ira_reassign_conflict_allocnos): Iterate over allocno subobjects.
	(slot_coalesced_allocno_live_ranges_intersect_p): Likewise.
	(setup_slot_coalesced_allocno_live_ranges): Likewise.
	(allocno_reload_assign): Likewise.
	(ira_reassign_pseudos): Likewise.
	(fast_allocation): Likewise.
	* ira-conflicts.c (build_conflict_bit_table): Likewise.
	(print_allocno_conflicts): Likewise.
	(ira_build_conflicts): Likewise.
	(allocnos_conflict_for_copy_p): Renamed from allocnos_conflict_p.  All
	callers changed.  Test subword 0 of each allocno for conflicts.
	(build_object_conflicts): Renamed from build_allocno_conflicts.  All
	callers changed.  Iterate over allocno subobjects.
	* ira-emit.c (modify_move_list): Iterate over allocno subobjects.
	* ira-int.h (struct ira_allocno): New member. num_objects.  Rename object
	to objects and change it into an array.
	(ALLOCNO_OBJECT): Add new argument N.
	(ALLOCNO_NUM_OBJECTS, OBJECT_SUBWORD): New macros.
	(ira_create_allocno_objects): Renamed from ira_create_allocno_object.
	(ior_hard_reg_conflicts): Declare.
	(ira_add_live_range_to_object): Declare.
	(ira_allocno_object_iterator): New.
	(ira_allocno_object_iter_init, ira_allocno_object_iter_cond): New.
	(FOR_EACH_ALLOCNO_OBJECT): New macro.
	* ira-lives.c (objects_live): Renamed from allocnos_live; all uses changed.
	(allocnos_processed): New sparseset.
	(make_object_born): Renamed from make_allocno_born; take an ira_object_t
	argument.  All callers changed.
	(make_object_dead): Renamed from make_allocno_dead; take an ira_object t
	argument.  All callers changed.
	(update_allocno_pressure_excess_length): Take an ira_obejct_t argument.
	All callers changed.
	(mark_pseudo_regno_live): Iterate over allocno subobjects.
	(mark_pseudo_regno_dead): Likewise.
	(mark_pseudo_regno_subword_live, mark_pseudo_regno_subword_dead): New
	functions.
	(mark_ref_live): Detect subword accesses and call
	mark_pseudo_regno_subword_live as appropriate.
	(mark_ref_dead): Likewise for mark_pseudo_regno_subword_dead.
	(process_bb_nodes_live): Deal with object-related updates first; set
	and test bits in allocnos_processed to avoid computing allocno
	statistics more than once.
	(create_start_finish_chains): Iterate over objects, not allocnos.
	(print_object_live_ranges): New function.
	(print_allocno_live_ranges): Use it.
	(ira_create_allocno_live_ranges): Allocate and free allocnos_processed
	and objects_live.



git-svn-id: svn+ssh://gcc.gnu.org/svn/gcc/trunk@162418 138bc75d-0d04-0410-961f-82ee72b054a4

1 files changed, 238 insertions, 106 deletions

diff --git a/gcc/ira-lives.c b/gcc/ira-lives.c
index 5f5fef52ab2..5b75f54e5d3 100644
--- a/gcc/ira-lives.c
+++ b/gcc/ira-lives.c
@@ -68,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;
@@ -82,18 +86,17 @@ 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)
     {
-      ira_allocno_t allocno = ira_allocnos[i];
-      ira_object_t obj = ALLOCNO_OBJECT (allocno);
+      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);
     }
@@ -107,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)
 {
-  ira_object_t obj = ALLOCNO_OBJECT (a);
-  live_range_t p = OBJECT_LIVE_RANGES (obj);
+  live_range_t lr = OBJECT_LIVE_RANGES (obj);
 
-  sparseset_set_bit (allocnos_live, ALLOCNO_NUM (a));
+  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))
-    OBJECT_LIVE_RANGES (obj)
-      = ira_create_live_range (obj, curr_point, -1, p);
+  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;
@@ -139,7 +142,6 @@ update_allocno_pressure_excess_length (ira_allocno_t a)
        (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 = OBJECT_LIVE_RANGES (obj);
@@ -150,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)
 {
-  ira_object_t obj = ALLOCNO_OBJECT (a);
-  live_range_t p = OBJECT_LIVE_RANGES (obj);
+  live_range_t lr;
 
-  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
@@ -216,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;
@@ -234,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;
@@ -243,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)
 {
@@ -282,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);
 }
@@ -299,8 +358,8 @@ 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;
-  int nregs;
 
   if (a == NULL)
     return;
@@ -308,18 +367,61 @@ 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);
+  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;
+  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)
+    /* 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)
 {
@@ -347,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);
 }
@@ -468,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
@@ -836,13 +952,12 @@ 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)
 	    {
-	      ira_object_t obj = ALLOCNO_OBJECT (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.  */
@@ -897,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);
@@ -1011,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.  */
@@ -1033,18 +1141,31 @@ process_bb_node_lives (ira_loop_tree_node_t loop_tree_node)
 		      || find_reg_note (insn, REG_SETJMP,
 					NULL_RTX) != NULL_RTX)
 		    {
-		      ira_object_t obj = ALLOCNO_OBJECT (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))
 		    {
-		      ira_object_t obj = ALLOCNO_OBJECT (a);
-		      IOR_HARD_REG_SET (OBJECT_TOTAL_CONFLICT_HARD_REGS (obj),
-					call_used_reg_set);
 		      IOR_HARD_REG_SET (OBJECT_CONFLICT_HARD_REGS (obj),
 					call_used_reg_set);
+		      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)++;
 		}
 	    }
 
@@ -1102,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);
@@ -1119,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++;
 
@@ -1144,31 +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)
-    {
-      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;
-	  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
@@ -1202,7 +1317,7 @@ remove_some_program_points_and_update_live_ranges (void)
       {
 	ira_assert (r->start <= r->finish);
 	bitmap_set_bit (born_or_died, r->start);
-	  bitmap_set_bit (born_or_died, r->finish);
+	bitmap_set_bit (born_or_died, r->finish);
       }
 
   map = (int *) ira_allocate (sizeof (int) * ira_max_point);
@@ -1223,6 +1338,7 @@ remove_some_program_points_and_update_live_ranges (void)
 	r->start = map[r->start];
 	r->finish = map[r->finish];
       }
+
   ira_free (map);
 }
 
@@ -1242,13 +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)
 {
-  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, OBJECT_LIVE_RANGES (obj));
+  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.  */
@@ -1277,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
@@ -1296,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.  */