* timevar.def (TV_LRA, TV_LRA_ELIMINATE, TV_LRA_INHERITANCE,
	TV_LRA_CREATE_LIVE_RANGES, TV_LRA_ASSIGN, TV_LRA_COALESCE): New.
	* lra.c (get_static_insn_data): Use XNEW* instead of xmalloc,
	or XRESIZEVEC instead of xrealloc.
	(check_and_expand_insn_recog_data): Likewise.
	(setup_operand_alternative): Likewise.
	(lra_set_insn_recog_data): Likewise.
	(init_reg_info): Likewise.
	(expand_reg_info): Likewise.
	(remove_scratches): Likewise.
	(lra): Push/pop TV_LRA.
	* lra-eliminations.c (lra_eliminate): Push/pop TV_LRA_ELIMINATE.
	* lra-spills.c (assign_spill_hard_regs): Use XNEW* instead of xmalloc.
	(lra_spill): Likewise.
	* lra-lives.c (create_start_finish_chains): Likewise.
	(remove_some_program_points_and_update_live_ranges): Likewise.
	(lra_create_live_ranges): Push/pop TV_LRA_CREATE_LIVE_RANGES.
	* lra-coalesce.c (lra_coalesce): Push/pop TV_LRA_COALESCE.
	Use XNEW* instead of xmalloc.
	* lra-constraints.c (lra_inheritance): Likewise.
	* lra-assigns.c (init_regno_assign_info): Use XNEW* instead of xmalloc.
	(init_lives): Likewise.
	(assign_by_spills): Likewise.
	(lra_assign): Likewise,  Push/pop TV_LRA_ASSIGN.

Index: timevar.def
===================================================================
--- timevar.def	(revision 191858)
+++ timevar.def	(working copy)
@@ -224,6 +224,12 @@ DEFTIMEVAR (TV_MODE_SWITCH           , "
 DEFTIMEVAR (TV_SMS		     , "sms modulo scheduling")
 DEFTIMEVAR (TV_SCHED                 , "scheduling")
 DEFTIMEVAR (TV_IRA	   	     , "integrated RA")
+DEFTIMEVAR (TV_LRA		     , "LRA non-specific")
+DEFTIMEVAR (TV_LRA_ELIMINATE	     , "LRA virtuals eliminatenon")
+DEFTIMEVAR (TV_LRA_INHERITANCE	     , "LRA reload inheritance")
+DEFTIMEVAR (TV_LRA_CREATE_LIVE_RANGES, "LRA create live ranges")
+DEFTIMEVAR (TV_LRA_ASSIGN	     , "LRA hard reg assignment")
+DEFTIMEVAR (TV_LRA_COALESCE	     , "LRA coalesce pseudo regs")
 DEFTIMEVAR (TV_RELOAD	   	     , "reload")
 DEFTIMEVAR (TV_RELOAD_CSE_REGS       , "reload CSE regs")
 DEFTIMEVAR (TV_GCSE_AFTER_RELOAD      , "load CSE after reload")
Index: lra.c
===================================================================
--- lra.c	(revision 191858)
+++ lra.c	(working copy)
@@ -585,15 +585,16 @@ static struct lra_static_insn_data *
 get_static_insn_data (int icode, int nop, int ndup, int nalt)
 {
   struct lra_static_insn_data *data;
+  size_t n_bytes;
 
   lra_assert (icode < LAST_INSN_CODE);
   if (icode >= 0 && (data = insn_code_data[icode]) != NULL)
     return data;
   lra_assert (nop >= 0 && ndup >= 0 && nalt >= 0);
-  data = ((struct lra_static_insn_data *)
-	  xmalloc (sizeof (struct lra_static_insn_data)
+  n_bytes = sizeof (struct lra_static_insn_data)
 		   + sizeof (struct lra_operand_data) * nop
-		   + sizeof (int) * ndup));
+	    + sizeof (int) * ndup;
+  data = XNEWVAR (struct lra_static_insn_data, n_bytes);
   data->n_operands = nop;
   data->n_dups = ndup;
   data->n_alternatives = nalt;
@@ -650,10 +651,9 @@ check_and_expand_insn_recog_data (int in
     return;
   old = lra_insn_recog_data_len;
   lra_insn_recog_data_len = index * 3 / 2 + 1;
-  lra_insn_recog_data
-    = (lra_insn_recog_data_t *) xrealloc (lra_insn_recog_data,
-					  lra_insn_recog_data_len
-					  * sizeof (lra_insn_recog_data_t));
+  lra_insn_recog_data = XRESIZEVEC (lra_insn_recog_data_t,
+				    lra_insn_recog_data,
+				    lra_insn_recog_data_len);
   for (i = old; i < lra_insn_recog_data_len; i++)
     lra_insn_recog_data[i] = NULL;
 }
@@ -717,9 +717,8 @@ setup_operand_alternative (lra_insn_reco
       return;
     }
   nalt = static_data->n_alternatives;
-  static_data->operand_alternative
-    = ((struct operand_alternative *)
-       xmalloc (nalt * nop * sizeof (struct operand_alternative)));
+  static_data->operand_alternative = XNEWVEC (struct operand_alternative,
+					      nalt * nop);
   memset (static_data->operand_alternative, 0,
 	  nalt * nop * sizeof (struct operand_alternative));
   if (icode >= 0)
@@ -1006,8 +1005,7 @@ lra_set_insn_recog_data (rtx insn)
 	/* It might be a new simple insn which is not recognized yet.  */
 	INSN_CODE (insn) = icode = recog (PATTERN (insn), insn, 0);
     }
-  data
-    = (lra_insn_recog_data_t) xmalloc (sizeof (struct lra_insn_recog_data));
+  data = XNEW (struct lra_insn_recog_data);
   lra_insn_recog_data[uid] = data;
   data->insn = insn;
   data->used_insn_alternative = -1;
@@ -1021,7 +1019,7 @@ lra_set_insn_recog_data (rtx insn)
 #ifdef HAVE_ATTR_enabled
       data->alternative_enabled_p = NULL;
 #endif
-      data->operand_loc = (rtx **) xmalloc (sizeof (rtx *));
+      data->operand_loc = XNEWVEC (rtx *, 1);
       data->operand_loc[0] = &INSN_VAR_LOCATION_LOC (insn);
       return data;
     }
@@ -1043,7 +1041,7 @@ lra_set_insn_recog_data (rtx insn)
 	     operands.	*/
 	  lra_assert (nop <= MAX_RECOG_OPERANDS);
 	  if (nop != 0)
-	    data->operand_loc = (rtx **) xmalloc (nop * sizeof (rtx *));
+	    data->operand_loc = XNEWVEC (rtx *, nop);
 	  /* Now get the operand values and constraints out of the
 	     insn.  */
 	  decode_asm_operands (PATTERN (insn), NULL,
@@ -1088,8 +1086,7 @@ lra_set_insn_recog_data (rtx insn)
 	locs = NULL;
       else
 	{
-	  
-	  locs = (rtx **) xmalloc (n * sizeof (rtx *));
+	  locs = XNEWVEC (rtx *, n);
 	  memcpy (locs, recog_data.operand_loc, n * sizeof (rtx *));
 	}
       data->operand_loc = locs;
@@ -1098,7 +1095,7 @@ lra_set_insn_recog_data (rtx insn)
 	locs = NULL;
       else
 	{
-	  locs = (rtx **) xmalloc (n * sizeof (rtx *));
+	  locs = XNEWVEC (rtx *, n);
 	  memcpy (locs, recog_data.dup_loc, n * sizeof (rtx *));
 	}
       data->dup_loc = locs;
@@ -1108,8 +1105,7 @@ lra_set_insn_recog_data (rtx insn)
 
 	n = insn_static_data->n_alternatives;
 	lra_assert (n >= 0);
-	data->alternative_enabled_p
-	  = bp = (bool *) xmalloc (n * sizeof (bool));
+	data->alternative_enabled_p = bp = XNEWVEC (bool, n);
 	/* Cache the insn because we don't want to call extract_insn
 	   from get_attr_enabled as extract_insn modifies
 	   which_alternative.  The attribute enabled should not depend
@@ -1161,7 +1157,7 @@ lra_set_insn_recog_data (rtx insn)
       if (n_hard_regs != 0)
 	{
 	  arg_hard_regs[n_hard_regs++] = -1;
-	  data->arg_hard_regs = ((int *) xmalloc (n_hard_regs * sizeof (int)));
+	  data->arg_hard_regs = XNEWVEC (int, n_hard_regs);
 	  memcpy (data->arg_hard_regs, arg_hard_regs,
 		  sizeof (int) * n_hard_regs);
 	}
@@ -1388,8 +1384,7 @@ init_reg_info (void)
 
   last_reg_value = 0;
   reg_info_size = max_reg_num () * 3 / 2 + 1;
-  lra_reg_info
-    = (struct lra_reg *) xmalloc (reg_info_size * sizeof (struct lra_reg));
+  lra_reg_info = XNEWVEC (struct lra_reg, reg_info_size);
   for (i = 0; i < reg_info_size; i++)
     {
       bitmap_initialize (&lra_reg_info[i].insn_bitmap, &reg_obstack);
@@ -1437,9 +1432,7 @@ expand_reg_info (void)
   if (reg_info_size > max_reg_num ())
     return;
   reg_info_size = max_reg_num () * 3 / 2 + 1;
-  lra_reg_info
-    = (struct lra_reg *) xrealloc (lra_reg_info,
-				   reg_info_size * sizeof (struct lra_reg));
+  lra_reg_info = XRESIZEVEC (struct lra_reg, lra_reg_info, reg_info_size);
   for (i = old; i < reg_info_size; i++)
     {
       bitmap_initialize (&lra_reg_info[i].insn_bitmap, &reg_obstack);
@@ -1904,7 +1897,7 @@ remove_scratches (void)
 				      *id->operand_loc[i], ALL_REGS, NULL);
 	      add_reg_note (insn, REG_UNUSED, reg);
 	      lra_update_dup (id, i);
-	      loc = (struct loc *) xmalloc (sizeof (struct loc));
+	      loc = XNEW (struct loc);
 	      loc->insn = insn;
 	      loc->nop = i;
 	      VEC_safe_push (loc_t, heap, scratches, loc);
@@ -2193,6 +2186,7 @@ lra (FILE *f)
 
   lra_dump_file = f;
 
+  timevar_push (TV_LRA);
 
   init_insn_recog_data ();
 
@@ -2271,6 +2265,7 @@ lra (FILE *f)
 	     to use a constant pool.  */
 	  lra_eliminate (false);
 	  lra_inheritance ();
+
 	  /* We need live ranges for lra_assign -- so build them.  */
 	  lra_create_live_ranges (true);
 	  live_p = true;
@@ -2343,6 +2338,8 @@ lra (FILE *f)
 #ifdef ENABLE_CHECKING
   check_rtl (true);
 #endif
+
+  timevar_pop (TV_LRA);
 }
 
 /* Called once per compiler to initialize LRA data once.  */
Index: lra-eliminations.c
===================================================================
--- lra-eliminations.c	(revision 191858)
+++ lra-eliminations.c	(working copy)
@@ -1297,6 +1297,8 @@ lra_eliminate (bool final_p)
   struct elim_table *ep;
   int regs_num = max_reg_num ();
 
+  timevar_push (TV_LRA_ELIMINATE);
+
   bitmap_initialize (&insns_with_changed_offsets, &reg_obstack);
   if (final_p)
     {
@@ -1317,7 +1319,7 @@ lra_eliminate (bool final_p)
     {
       update_reg_eliminate (&insns_with_changed_offsets);
       if (bitmap_empty_p (&insns_with_changed_offsets))
-	return;
+	goto lra_eliminate_done;
     }
   if (lra_dump_file != NULL)
     {
@@ -1349,4 +1351,7 @@ lra_eliminate (bool final_p)
 	  process_insn_for_elimination (insn, final_p);
       }
   bitmap_clear (&insns_with_changed_offsets);
+
+lra_eliminate_done:
+  timevar_pop (TV_LRA_ELIMINATE);
 }
Index: lra-spills.c
===================================================================
--- lra-spills.c	(revision 191858)
+++ lra-spills.c	(working copy)
@@ -266,8 +266,7 @@ assign_spill_hard_regs (int *pseudo_regn
   if (! lra_reg_spill_p)
     return n;
   /* Set up reserved hard regs for every program point.	 */
-  reserved_hard_regs = (HARD_REG_SET *) xmalloc (sizeof (HARD_REG_SET)
-						 * lra_live_max_point);
+  reserved_hard_regs = XNEWVEC (HARD_REG_SET, lra_live_max_point);
   for (p = 0; p < lra_live_max_point; p++)
     COPY_HARD_REG_SET (reserved_hard_regs[p], lra_no_alloc_regs);
   for (i = FIRST_PSEUDO_REGISTER; i < regs_num; i++)
@@ -332,7 +331,8 @@ assign_spill_hard_regs (int *pseudo_regn
 	= gen_raw_REG (PSEUDO_REGNO_MODE (regno), hard_regno);
       for (nr = 0;
 	   nr < hard_regno_nregs[hard_regno][lra_reg_info[regno].biggest_mode];
-	   nr++);
+	   nr++)
+	/* Just loop.  */;
       df_set_regs_ever_live (hard_regno + nr, true);
     }
   bitmap_clear (&ok_insn_bitmap);
@@ -518,8 +518,8 @@ lra_spill (void)
   int *pseudo_regnos;
 
   regs_num = max_reg_num ();
-  spill_hard_reg = (rtx *) xmalloc (sizeof (rtx) * regs_num);
-  pseudo_regnos = (int *) xmalloc (sizeof (int) * regs_num);
+  spill_hard_reg = XNEWVEC (rtx, regs_num);
+  pseudo_regnos = XNEWVEC (int, regs_num);
   for (n = 0, i = FIRST_PSEUDO_REGISTER; i < regs_num; i++)
     if (lra_reg_info[i].nrefs != 0 && lra_get_regno_hard_regno (i) < 0
 	/* We do not want to assign memory for former scratches.  */
@@ -529,9 +529,8 @@ lra_spill (void)
 	pseudo_regnos[n++] = i;
       }
   lra_assert (n > 0);
-  pseudo_slots = (struct pseudo_slot *) xmalloc (sizeof (struct pseudo_slot)
-						 * regs_num);
-  slots = (struct slot *) xmalloc (sizeof (struct slot) * regs_num);
+  pseudo_slots = XNEWVEC (struct pseudo_slot, regs_num);
+  slots = XNEWVEC (struct slot, regs_num);
   /* Sort regnos according their usage frequencies.  */
   qsort (pseudo_regnos, n, sizeof (int), regno_freq_compare);
   n = assign_spill_hard_regs (pseudo_regnos, n);
Index: lra-lives.c
===================================================================
--- lra-lives.c	(revision 191858)
+++ lra-lives.c	(working copy)
@@ -770,16 +770,8 @@ create_start_finish_chains (void)
   int i, max_regno;
   lra_live_range_t r;
 
-  lra_start_point_ranges
-    = (lra_live_range_t *) xmalloc (lra_live_max_point
-				    * sizeof (lra_live_range_t));
-  memset (lra_start_point_ranges, 0,
-	  lra_live_max_point * sizeof (lra_live_range_t));
-  lra_finish_point_ranges
-    = (lra_live_range_t *) xmalloc (lra_live_max_point
-				    * sizeof (lra_live_range_t));
-  memset (lra_finish_point_ranges, 0,
-	  lra_live_max_point * sizeof (lra_live_range_t));
+  lra_start_point_ranges = XCNEWVEC (lra_live_range_t, lra_live_max_point);
+  lra_finish_point_ranges = XCNEWVEC (lra_live_range_t, lra_live_max_point);
   max_regno = max_reg_num ();
   for (i = FIRST_PSEUDO_REGISTER; i < max_regno; i++)
     {
@@ -835,7 +827,7 @@ remove_some_program_points_and_update_li
     }
   born_or_dead = sbitmap_alloc (lra_live_max_point);
   sbitmap_a_or_b (born_or_dead, born, dead);
-  map = (int *) xmalloc (sizeof (int) * lra_live_max_point);
+  map = XCNEWVEC (int, lra_live_max_point);
   n = -1;
   prev_born_p = prev_dead_p = false;
   EXECUTE_IF_SET_IN_SBITMAP (born_or_dead, 0, i, sbi)
@@ -962,6 +954,8 @@ lra_create_live_ranges (bool all_p)
   basic_block bb;
   int i, hard_regno, max_regno = max_reg_num ();
 
+  timevar_push (TV_LRA_CREATE_LIVE_RANGES);
+
   complete_info_p = all_p;
   if (lra_dump_file != NULL)
     fprintf (lra_dump_file,
@@ -1016,6 +1010,7 @@ lra_create_live_ranges (bool all_p)
   sparseset_free (pseudos_live_through_setjumps);
   sparseset_free (pseudos_live);
   compress_live_ranges ();
+  timevar_pop (TV_LRA_CREATE_LIVE_RANGES);
 }
 
 /* Finish all live ranges.  */
Index: lra-coalesce.c
===================================================================
--- lra-coalesce.c	(revision 191858)
+++ lra-coalesce.c	(working copy)
@@ -221,15 +221,17 @@ lra_coalesce (void)
   bitmap_head involved_insns_bitmap, split_origin_bitmap;
   bitmap_iterator bi;
 
+  timevar_push (TV_LRA_COALESCE);
+
   if (lra_dump_file != NULL)
     fprintf (lra_dump_file,
 	     "\n********** Pseudos coalescing #%d: **********\n\n",
 	     ++lra_coalesce_iter);
-  first_coalesced_pseudo = (int *) xmalloc (sizeof (int) * max_regno);
-  next_coalesced_pseudo = (int *) xmalloc (sizeof (int) * max_regno);
+  first_coalesced_pseudo = XNEWVEC (int, max_regno);
+  next_coalesced_pseudo = XNEWVEC (int, max_regno);
   for (i = 0; i < max_regno; i++)
     first_coalesced_pseudo[i] = next_coalesced_pseudo[i] = i;
-  sorted_moves = (rtx *) xmalloc (get_max_uid () * sizeof (rtx));
+  sorted_moves = XNEWVEC (rtx, get_max_uid ());
   mv_num = 0;
   /* Collect pseudos whose live ranges were split.  */
   bitmap_initialize (&split_origin_bitmap, &reg_obstack);
@@ -371,5 +373,6 @@ lra_coalesce (void)
   free (sorted_moves);
   free (next_coalesced_pseudo);
   free (first_coalesced_pseudo);
+  timevar_pop (TV_LRA_COALESCE);
   return coalesced_moves != 0;
 }
Index: lra-constraints.c
===================================================================
--- lra-constraints.c	(revision 191858)
+++ lra-constraints.c	(working copy)
@@ -4859,14 +4859,14 @@ lra_inheritance (void)
   basic_block bb, start_bb;
   edge e;
 
+  timevar_push (TV_LRA_INHERITANCE);
+
   lra_inheritance_iter++;
   if (lra_dump_file != NULL)
     fprintf (lra_dump_file, "\n********** Inheritance #%d: **********\n\n",
 	     lra_inheritance_iter);
   curr_usage_insns_check = 0;
-  usage_insns
-    = (struct usage_insns *) xmalloc (sizeof (struct usage_insns)
-				      * lra_constraint_new_regno_start);
+  usage_insns = XNEWVEC (struct usage_insns, lra_constraint_new_regno_start);
   for (i = 0; i < lra_constraint_new_regno_start; i++)
     usage_insns[i].check = 0;
   bitmap_initialize (&check_only_regs, &reg_obstack);
@@ -4907,6 +4907,8 @@ lra_inheritance (void)
   bitmap_clear (&live_regs);
   bitmap_clear (&check_only_regs);
   free (usage_insns);
+
+  timevar_pop (TV_LRA_INHERITANCE);
 }
 
 
Index: lra-assigns.c
===================================================================
--- lra-assigns.c	(revision 191858)
+++ lra-assigns.c	(working copy)
@@ -140,9 +140,7 @@ init_regno_assign_info (void)
   int i, regno1, regno2;
   lra_copy_t cp;
 
-  regno_assign_info
-    = (struct regno_assign_info *) xmalloc (sizeof (struct regno_assign_info)
-				       * max_reg_num ());
+  regno_assign_info = XNEWVEC (struct regno_assign_info, max_reg_num ());
   for (i = FIRST_PSEUDO_REGISTER; i < max_reg_num (); i++)
     {
       regno_assign_info[i].first = i;
@@ -242,12 +240,10 @@ init_lives (void)
 
   live_range_hard_reg_pseudos = sparseset_alloc (max_reg_num ());
   live_range_reload_pseudos = sparseset_alloc (max_reg_num ());
-  live_hard_reg_pseudos = (bitmap_head *) xmalloc (sizeof (bitmap_head)
-						   * lra_live_max_point);
+  live_hard_reg_pseudos = XNEWVEC (bitmap_head, lra_live_max_point);
   for (i = 0; i < lra_live_max_point; i++)
     bitmap_initialize (&live_hard_reg_pseudos[i], &reg_obstack);
-  live_pseudos_reg_renumber
-    = (int *) xmalloc (sizeof (int) * max_reg_num ());
+  live_pseudos_reg_renumber = XNEWVEC (int, max_reg_num ());
   for (i = 0; i < max_reg_num (); i++)
     live_pseudos_reg_renumber[i] = -1;
 }
@@ -305,8 +301,7 @@ init_live_reload_and_inheritance_pseudos
   lra_live_range_t r;
   
   conflict_reload_and_inheritance_pseudos = sparseset_alloc (max_reg_num ());
-  live_reload_and_inheritance_pseudos
-    = (bitmap_head *) xmalloc (sizeof (bitmap_head) * lra_live_max_point);
+  live_reload_and_inheritance_pseudos = XNEWVEC (bitmap_head, lra_live_max_point);
   for (p = 0; p < lra_live_max_point; p++)
     bitmap_initialize (&live_reload_and_inheritance_pseudos[p], &reg_obstack);
   for (i = lra_constraint_new_regno_start; i < max_reg_num (); i++)
@@ -1097,10 +1092,7 @@ assign_by_spills (void)
   bitmap_initialize (&ignore_pseudos_bitmap, &reg_obstack);
   bitmap_initialize (&spill_pseudos_bitmap, &reg_obstack);
   bitmap_initialize (&best_spill_pseudos_bitmap, &reg_obstack);
-  update_hard_regno_preference_check = (int *) xmalloc (sizeof (int)
-							* max_reg_num ());
-  memset (update_hard_regno_preference_check, 0,
-	  sizeof (int) * max_reg_num ());
+  update_hard_regno_preference_check = XCNEWVEC (int, max_reg_num ());
   curr_update_hard_regno_preference_check = 0;
   memset (try_hard_reg_pseudos_check, 0, sizeof (try_hard_reg_pseudos_check));
   for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
@@ -1261,11 +1253,12 @@ lra_assign (void)
   bitmap_head insns_to_process;
   bool no_spills_p;
 
+  timevar_push (TV_LRA_ASSIGN);
+
   init_lives ();
-  sorted_pseudos = (int *) xmalloc (sizeof (int) * max_reg_num ());
-  sorted_reload_pseudos = (int *) xmalloc (sizeof (int) * max_reg_num ());
-  regno_allocno_class_array
-    = (enum reg_class *) xmalloc (sizeof (enum reg_class) * max_reg_num ());
+  sorted_pseudos = XNEWVEC (int, max_reg_num ());
+  sorted_reload_pseudos = XNEWVEC (int, max_reg_num ());
+  regno_allocno_class_array = XNEWVEC (enum reg_class, max_reg_num ());
   for (i = FIRST_PSEUDO_REGISTER; i < max_reg_num (); i++)
     regno_allocno_class_array[i] = lra_get_allocno_class (i);
   init_regno_assign_info ();
@@ -1312,5 +1305,6 @@ lra_assign (void)
   free (sorted_pseudos);
   free (sorted_reload_pseudos);
   finish_lives ();
+  timevar_pop (TV_LRA_ASSIGN);
   return no_spills_p;
 }