dwarf2out.c (new_cfi, [...]): Fix -Wc++-compat and/or -Wcast-qual warnings.

	* dwarf2out.c (new_cfi, queue_reg_save, dwarf2out_begin_prologue,
	dwarf2out_frame_init, new_loc_descr, new_die, lookup_decl_die,
	lookup_decl_loc, add_var_loc_to_decl, compute_section_prefix,
	assign_symbol_names, htab_cu_hash, htab_cu_eq, htab_cu_del,
	build_abbrev_table, new_loc_list, output_comp_unit, add_arange,
	add_ranges_num, add_ranges_by_labels, file_info_cmp,
	file_name_acquire, output_file_names, add_const_value_attribute,
	premark_used_types_helper, file_table_eq, file_table_hash,
	lookup_filename, dwarf2out_var_location, dwarf2out_source_line,
	dwarf2out_init, file_table_relative_p): Fix -Wc++-compat and/or
	-Wcast-qual warnings.
	* ebitmap.c (ebitmap_array_grow, ebitmap_array_init,
	ebitmap_alloc, ebitmap_ior, ebitmap_and_compl): Likewise.
	* emit-rtl.c (get_mem_attrs, get_reg_attrs, gen_rtvec,
	gen_reg_rtx, start_sequence, init_emit): Likewise.
	* et-forest.c (et_new_occ, et_new_tree): Likewise.
	* except.c (init_eh_for_function, gen_eh_region,
	remove_unreachable_regions, add_ehl_entry, duplicate_eh_regions_1,
	arh_to_landing_pad, arh_to_label, add_action_record,
	add_call_site, switch_to_exception_section): Likewise.
	* expmed.c (synth_mult): Likewise.
	* expr.c (gen_group_rtx, emit_group_load, emit_group_store,
	store_expr): Likewise.
	* final.c (shorten_branches, final_scan_insn, debug_queue_symbol):
	Likewise.
	* function.c (assign_stack_temp_for_type,
	allocate_struct_function, match_asm_constraints_1): Likewise.
	* gcov-io.c (gcov_allocate): Likewise.
	* gcse.c (GNEW, GCNEW, GNEWVEC, GCNEWVEC, GRESIZEVEC, GNEWVAR,
	GCNEWVAR, GRESIZEVAR, GOBNEW, GOBNEWVAR): New.
	(gcse_main, alloc_gcse_mem, alloc_gcse_mem, alloc_reg_set_mem,
	record_one_set, insert_expr_in_table, insert_set_in_table,
	dump_hash_table, compute_hash_table_work, alloc_hash_table,
	pre_ldst_expr_hash, pre_ldst_expr_eq, find_rtx_in_ldst,
	reg_set_info, reg_clear_last_set): Fix -Wc++-compat and/or
	-Wcast-qual warnings.

From-SVN: r137136

gcc/ChangeLog

 2008-06-25  Kaveh R. Ghazi  <ghazi@caip.rutgers.edu>
 
+	* dwarf2out.c (new_cfi, queue_reg_save, dwarf2out_begin_prologue,
+	dwarf2out_frame_init, new_loc_descr, new_die, lookup_decl_die,
+	lookup_decl_loc, add_var_loc_to_decl, compute_section_prefix,
+	assign_symbol_names, htab_cu_hash, htab_cu_eq, htab_cu_del,
+	build_abbrev_table, new_loc_list, output_comp_unit, add_arange,
+	add_ranges_num, add_ranges_by_labels, file_info_cmp,
+	file_name_acquire, output_file_names, add_const_value_attribute,
+	premark_used_types_helper, file_table_eq, file_table_hash,
+	lookup_filename, dwarf2out_var_location, dwarf2out_source_line,
+	dwarf2out_init, file_table_relative_p): Fix -Wc++-compat and/or
+	-Wcast-qual warnings.
+	* ebitmap.c (ebitmap_array_grow, ebitmap_array_init,
+	ebitmap_alloc, ebitmap_ior, ebitmap_and_compl): Likewise.
+	* emit-rtl.c (get_mem_attrs, get_reg_attrs, gen_rtvec,
+	gen_reg_rtx, start_sequence, init_emit): Likewise.
+	* et-forest.c (et_new_occ, et_new_tree): Likewise.
+	* except.c (init_eh_for_function, gen_eh_region,
+	remove_unreachable_regions, add_ehl_entry, duplicate_eh_regions_1,
+	arh_to_landing_pad, arh_to_label, add_action_record,
+	add_call_site, switch_to_exception_section): Likewise.
+	* expmed.c (synth_mult): Likewise.
+	* expr.c (gen_group_rtx, emit_group_load, emit_group_store,
+	store_expr): Likewise.
+	* final.c (shorten_branches, final_scan_insn, debug_queue_symbol):
+	Likewise.
+	* function.c (assign_stack_temp_for_type,
+	allocate_struct_function, match_asm_constraints_1): Likewise.
+	* gcov-io.c (gcov_allocate): Likewise.
+	* gcse.c (GNEW, GCNEW, GNEWVEC, GCNEWVEC, GRESIZEVEC, GNEWVAR,
+	GCNEWVAR, GRESIZEVAR, GOBNEW, GOBNEWVAR): New.
+	(gcse_main, alloc_gcse_mem, alloc_gcse_mem, alloc_reg_set_mem,
+	record_one_set, insert_expr_in_table, insert_set_in_table,
+	dump_hash_table, compute_hash_table_work, alloc_hash_table,
+	pre_ldst_expr_hash, pre_ldst_expr_eq, find_rtx_in_ldst,
+	reg_set_info, reg_clear_last_set): Fix -Wc++-compat and/or
+	-Wcast-qual warnings.
+
+2008-06-25  Kaveh R. Ghazi  <ghazi@caip.rutgers.edu>
+
 	* cse.c (approx_reg_cost_1, cse_insn): Fix -Wc++-compat and/or
 	-Wcast-qual warnings.
 	* gcc.c (process_command): Likewise.

gcc/ebitmap.c

@@ -118,7 +118,7 @@ ebitmap_array_grow (ebitmap map, unsigned int newsize)
   newsize += newsize / 4;
 
   map->n_elts = newsize;
-  map->elts = xrealloc (map->elts, sizeof (EBITMAP_ELT_TYPE) * newsize);
+  map->elts = XRESIZEVEC (EBITMAP_ELT_TYPE, map->elts, newsize);
 }
 
 /* Grow the internal word array for MAP so it is at least SIZE
@@ -161,7 +161,7 @@ ebitmap_array_init (ebitmap map, unsigned int size)
 {
   if (size > 0)
     {
-      map->elts = xmalloc (sizeof (EBITMAP_ELT_TYPE) * size);
+      map->elts = XNEWVEC (EBITMAP_ELT_TYPE, size);
       map->n_elts = size;
     }
   else
@@ -202,7 +202,7 @@ ebitmap_clear (ebitmap map)
 ebitmap
 ebitmap_alloc (unsigned int size)
 {
-  ebitmap ret = xmalloc (sizeof (struct ebitmap_def));
+  ebitmap ret = XNEW (struct ebitmap_def);
   if (size == 0)
     size = EBITMAP_ELT_BITS;
   ebitmap_array_init (ret, (size + EBITMAP_ELT_BITS - 1) / EBITMAP_ELT_BITS);
@@ -595,7 +595,7 @@ ebitmap_ior_into (ebitmap dst, ebitmap src)
 	}
     }
   newarraysize = src->numwords + dst->numwords;
-  newarray = xmalloc (newarraysize * sizeof (EBITMAP_ELT_TYPE));
+  newarray = XNEWVEC (EBITMAP_ELT_TYPE, newarraysize);
 
   EXECUTE_IF_SET_IN_SBITMAP (tempmask, 0, i, sbi)
     {
@@ -704,7 +704,7 @@ ebitmap_ior (ebitmap dst, ebitmap src1, ebitmap src2)
 	}
     }
   newarraysize = src1->numwords + src2->numwords;
-  newarray = xmalloc (newarraysize * sizeof (EBITMAP_ELT_TYPE));
+  newarray = XNEWVEC (EBITMAP_ELT_TYPE, newarraysize);
 
   EXECUTE_IF_SET_IN_SBITMAP (tempmask, 0, i, sbi)
     {
@@ -883,7 +883,7 @@ ebitmap_and_compl (ebitmap dst, ebitmap src1, ebitmap src2)
   sbitmap_copy (tempmask, src1->wordmask);
 
   newarraysize = src1->numwords;
-  newarray = xmalloc (newarraysize * sizeof (EBITMAP_ELT_TYPE));
+  newarray = XNEWVEC (EBITMAP_ELT_TYPE, newarraysize);
 
   EXECUTE_IF_SET_IN_SBITMAP (src1->wordmask, 0, i, sbi)
     {

gcc/emit-rtl.c

@@ -349,7 +349,7 @@ get_mem_attrs (alias_set_type alias, tree expr, rtx offset, rtx size,
       memcpy (*slot, &attrs, sizeof (mem_attrs));
     }
 
-  return *slot;
+  return (mem_attrs *) *slot;
 }
 
 /* Returns a hash code for X (which is a really a reg_attrs *).  */
@@ -398,7 +398,7 @@ get_reg_attrs (tree decl, int offset)
       memcpy (*slot, &attrs, sizeof (reg_attrs));
     }
 
-  return *slot;
+  return (reg_attrs *) *slot;
 }
 
 
@@ -812,7 +812,7 @@ gen_rtvec (int n, ...)
   if (n == 0)
     return NULL_RTVEC;		/* Don't allocate an empty rtvec...	*/
 
-  vector = alloca (n * sizeof (rtx));
+  vector = XALLOCAVEC (rtx, n);
 
   for (i = 0; i < n; i++)
     vector[i] = va_arg (p, rtx);
@@ -893,12 +893,11 @@ gen_reg_rtx (enum machine_mode mode)
       char *new;
       rtx *new1;
 
-      new = xrealloc (crtl->emit.regno_pointer_align, old_size * 2);
+      new = XRESIZEVEC (char, crtl->emit.regno_pointer_align, old_size * 2);
       memset (new + old_size, 0, old_size);
       crtl->emit.regno_pointer_align = (unsigned char *) new;
 
-      new1 = ggc_realloc (regno_reg_rtx,
-			  old_size * 2 * sizeof (rtx));
+      new1 = GGC_RESIZEVEC (rtx, regno_reg_rtx, old_size * 2);
       memset (new1 + old_size, 0, old_size * sizeof (rtx));
       regno_reg_rtx = new1;
 
@@ -4741,7 +4740,7 @@ start_sequence (void)
       free_sequence_stack = tem->next;
     }
   else
-    tem = ggc_alloc (sizeof (struct sequence_stack));
+    tem = GGC_NEW (struct sequence_stack);
 
   tem->next = seq_stack;
   tem->first = first_insn;
@@ -5047,11 +5046,10 @@ init_emit (void)
   crtl->emit.regno_pointer_align_length = LAST_VIRTUAL_REGISTER + 101;
 
   crtl->emit.regno_pointer_align
-    = xcalloc (crtl->emit.regno_pointer_align_length
-	       * sizeof (unsigned char), 1);
+    = XCNEWVEC (unsigned char, crtl->emit.regno_pointer_align_length);
 
   regno_reg_rtx
-    = ggc_alloc (crtl->emit.regno_pointer_align_length * sizeof (rtx));
+    = GGC_NEWVEC (rtx, crtl->emit.regno_pointer_align_length);
 
   /* Put copies of all the hard registers into regno_reg_rtx.  */
   memcpy (regno_reg_rtx,

gcc/et-forest.c

@@ -447,7 +447,7 @@ et_new_occ (struct et_node *node)
   
   if (!et_occurrences)
     et_occurrences = create_alloc_pool ("et_occ pool", sizeof (struct et_occ), 300);
-  nw = pool_alloc (et_occurrences);
+  nw = (struct et_occ *) pool_alloc (et_occurrences);
 
   nw->of = node;
   nw->parent = NULL;
@@ -470,7 +470,7 @@ et_new_tree (void *data)
   
   if (!et_nodes)
     et_nodes = create_alloc_pool ("et_node pool", sizeof (struct et_node), 300);
-  nw = pool_alloc (et_nodes);
+  nw = (struct et_node *) pool_alloc (et_nodes);
 
   nw->data = data;
   nw->father = NULL;

gcc/except.c

@@ -409,7 +409,7 @@ init_eh (void)
 void
 init_eh_for_function (void)
 {
-  cfun->eh = ggc_alloc_cleared (sizeof (struct eh_status));
+  cfun->eh = GGC_CNEW (struct eh_status);
 }
 
 /* Routines to generate the exception tree somewhat directly.
@@ -426,7 +426,7 @@ gen_eh_region (enum eh_region_type type, struct eh_region *outer)
 #endif
 
   /* Insert a new blank region as a leaf in the tree.  */
-  new = ggc_alloc_cleared (sizeof (*new));
+  new = GGC_CNEW (struct eh_region);
   new->type = type;
   new->outer = outer;
   if (outer)
@@ -632,8 +632,8 @@ remove_unreachable_regions (rtx insns)
   struct eh_region *r;
   rtx insn;
 
-  uid_region_num = xcalloc (get_max_uid (), sizeof(int));
-  reachable = xcalloc (cfun->eh->last_region_number + 1, sizeof(bool));
+  uid_region_num = XCNEWVEC (int, get_max_uid ());
+  reachable = XCNEWVEC (bool, cfun->eh->last_region_number + 1);
 
   for (i = cfun->eh->last_region_number; i > 0; --i)
     {
@@ -736,7 +736,7 @@ add_ehl_entry (rtx label, struct eh_region *region)
 
   LABEL_PRESERVE_P (label) = 1;
 
-  entry = ggc_alloc (sizeof (*entry));
+  entry = GGC_NEW (struct ehl_map_entry);
   entry->label = label;
   entry->region = region;
 
@@ -847,7 +847,7 @@ duplicate_eh_regions_1 (eh_region old, eh_region outer, int eh_offset)
 {
   eh_region ret, n;
 
-  ret = n = ggc_alloc (sizeof (struct eh_region));
+  ret = n = GGC_NEW (struct eh_region);
 
   *n = *old;
   n->outer = outer;
@@ -2587,7 +2587,7 @@ foreach_reachable_handler (int region_number, bool is_resx,
 static void
 arh_to_landing_pad (struct eh_region *region, void *data)
 {
-  rtx *p_handlers = data;
+  rtx *p_handlers = (rtx *) data;
   if (! *p_handlers)
     *p_handlers = alloc_INSN_LIST (region->landing_pad, NULL_RTX);
 }
@@ -2595,7 +2595,7 @@ arh_to_landing_pad (struct eh_region *region, void *data)
 static void
 arh_to_label (struct eh_region *region, void *data)
 {
-  rtx *p_handlers = data;
+  rtx *p_handlers = (rtx *) data;
   *p_handlers = alloc_INSN_LIST (region->label, *p_handlers);
 }
 
@@ -3055,7 +3055,7 @@ add_action_record (htab_t ar_hash, int filter, int next)
 
   if ((new = *slot) == NULL)
     {
-      new = xmalloc (sizeof (*new));
+      new = XNEW (struct action_record);
       new->offset = VARRAY_ACTIVE_SIZE (crtl->eh.action_record_data) + 1;
       new->filter = filter;
       new->next = next;
@@ -3191,7 +3191,7 @@ add_call_site (rtx landing_pad, int action)
 {
   call_site_record record;
   
-  record = ggc_alloc (sizeof (struct call_site_record));
+  record = GGC_NEW (struct call_site_record);
   record->landing_pad = landing_pad;
   record->action = action;
 
@@ -3522,7 +3522,7 @@ switch_to_exception_section (const char * ARG_UNUSED (fnname))
 #ifdef HAVE_LD_EH_GC_SECTIONS
 	  if (flag_function_sections)
 	    {
-	      char *section_name = xmalloc (strlen (fnname) + 32);
+	      char *section_name = XNEWVEC (char, strlen (fnname) + 32);
 	      sprintf (section_name, ".gcc_except_table.%s", fnname);
 	      s = get_section (section_name, flags, NULL);
 	      free (section_name);

gcc/expmed.c

@@ -2381,8 +2381,8 @@ synth_mult (struct algorithm *alg_out, unsigned HOST_WIDE_INT t,
 
   /* We'll be needing a couple extra algorithm structures now.  */
 
-  alg_in = alloca (sizeof (struct algorithm));
-  best_alg = alloca (sizeof (struct algorithm));
+  alg_in = XALLOCA (struct algorithm);
+  best_alg = XALLOCA (struct algorithm);
   best_cost = *cost_limit;
 
   /* Compute the hash index.  */

gcc/expr.c

@@ -1614,7 +1614,7 @@ gen_group_rtx (rtx orig)
   gcc_assert (GET_CODE (orig) == PARALLEL);
 
   length = XVECLEN (orig, 0);
-  tmps = alloca (sizeof (rtx) * length);
+  tmps = XALLOCAVEC (rtx, length);
 
   /* Skip a NULL entry in first slot.  */
   i = XEXP (XVECEXP (orig, 0, 0), 0) ? 0 : 1;
@@ -1819,7 +1819,7 @@ emit_group_load (rtx dst, rtx src, tree type, int ssize)
   rtx *tmps;
   int i;
 
-  tmps = alloca (sizeof (rtx) * XVECLEN (dst, 0));
+  tmps = XALLOCAVEC (rtx, XVECLEN (dst, 0));
   emit_group_load_1 (tmps, dst, src, type, ssize);
 
   /* Copy the extracted pieces into the proper (probable) hard regs.  */
@@ -1939,7 +1939,7 @@ emit_group_store (rtx orig_dst, rtx src, tree type ATTRIBUTE_UNUSED, int ssize)
     start = 1;
   finish = XVECLEN (src, 0);
 
-  tmps = alloca (sizeof (rtx) * finish);
+  tmps = XALLOCAVEC (rtx, finish);
 
   /* Copy the (probable) hard regs into pseudos.  */
   for (i = start; i < finish; i++)
@@ -4555,7 +4555,7 @@ store_expr (tree exp, rtx target, int call_param_p, bool nontemporal)
 	}
       str_copy_len = MIN (str_copy_len, exp_len);
       if (!can_store_by_pieces (str_copy_len, builtin_strncpy_read_str,
-				(void *) TREE_STRING_POINTER (exp),
+				CONST_CAST(char *, TREE_STRING_POINTER (exp)),
 				MEM_ALIGN (target), false))
 	goto normal_expr;
 
@@ -4563,7 +4563,7 @@ store_expr (tree exp, rtx target, int call_param_p, bool nontemporal)
 
       dest_mem = store_by_pieces (dest_mem,
 				  str_copy_len, builtin_strncpy_read_str,
-				  (void *) TREE_STRING_POINTER (exp),
+				  CONST_CAST(char *, TREE_STRING_POINTER (exp)),
 				  MEM_ALIGN (target), false,
 				  exp_len > str_copy_len ? 1 : 0);
       if (exp_len > str_copy_len)

gcc/final.c

@@ -858,8 +858,7 @@ shorten_branches (rtx first ATTRIBUTE_UNUSED)
       n_labels = max_labelno - min_labelno + 1;
       n_old_labels = old - min_labelno + 1;
 
-      label_align = xrealloc (label_align,
-			      n_labels * sizeof (struct label_alignment));
+      label_align = XRESIZEVEC (struct label_alignment, label_align, n_labels);
 
       /* Range of labels grows monotonically in the function.  Failing here
          means that the initialization of array got lost.  */
@@ -2181,7 +2180,7 @@ final_scan_insn (rtx insn, FILE *file, int optimize ATTRIBUTE_UNUSED,
 	if (asm_noperands (body) >= 0)
 	  {
 	    unsigned int noperands = asm_noperands (body);
-	    rtx *ops = alloca (noperands * sizeof (rtx));
+	    rtx *ops = XALLOCAVEC (rtx, noperands);
 	    const char *string;
 	    location_t loc;
 	    expanded_location expanded;
@@ -4056,8 +4055,7 @@ debug_queue_symbol (tree decl)
   if (symbol_queue_index >= symbol_queue_size)
     {
       symbol_queue_size += 10;
-      symbol_queue = xrealloc (symbol_queue,
-			       symbol_queue_size * sizeof (tree));
+      symbol_queue = XRESIZEVEC (tree, symbol_queue, symbol_queue_size);
     }
 
   symbol_queue[symbol_queue_index++] = decl;

gcc/function.c

@@ -598,7 +598,7 @@ assign_stack_temp_for_type (enum machine_mode mode, HOST_WIDE_INT size,
 
 	  if (best_p->size - rounded_size >= alignment)
 	    {
-	      p = ggc_alloc (sizeof (struct temp_slot));
+	      p = GGC_NEW (struct temp_slot);
 	      p->in_use = p->addr_taken = 0;
 	      p->size = best_p->size - rounded_size;
 	      p->base_offset = best_p->base_offset + rounded_size;
@@ -623,7 +623,7 @@ assign_stack_temp_for_type (enum machine_mode mode, HOST_WIDE_INT size,
     {
       HOST_WIDE_INT frame_offset_old = frame_offset;
 
-      p = ggc_alloc (sizeof (struct temp_slot));
+      p = GGC_NEW (struct temp_slot);
 
       /* We are passing an explicit alignment request to assign_stack_local.
 	 One side effect of that is assign_stack_local will not round SIZE
@@ -3841,7 +3841,7 @@ allocate_struct_function (tree fndecl, bool abstract_p)
   tree result;
   tree fntype = fndecl ? TREE_TYPE (fndecl) : NULL_TREE;
 
-  cfun = ggc_alloc_cleared (sizeof (struct function));
+  cfun = GGC_CNEW (struct function);
 
   current_function_funcdef_no = get_next_funcdef_no ();
 
@@ -5251,7 +5251,7 @@ match_asm_constraints_1 (rtx insn, rtx *p_sets, int noutputs)
   rtx op = SET_SRC (p_sets[0]);
   int ninputs = ASM_OPERANDS_INPUT_LENGTH (op);
   rtvec inputs = ASM_OPERANDS_INPUT_VEC (op);
-  bool *output_matched = alloca (noutputs * sizeof (bool));
+  bool *output_matched = XALLOCAVEC (bool, noutputs);
 
   memset (output_matched, 0, noutputs * sizeof (bool));
   for (i = 0; i < ninputs; i++)

gcc/gcov-io.c

@@ -196,7 +196,7 @@ gcov_allocate (unsigned length)
   new_size *= 2;
   
   gcov_var.alloc = new_size;
-  gcov_var.buffer = xrealloc (gcov_var.buffer, new_size << 2);
+  gcov_var.buffer = XRESIZEVAR (gcov_unsigned_t, gcov_var.buffer, new_size << 2);
 }
 #endif
 

gcc/gcse.c

@@ -639,6 +639,20 @@ static bool do_local_cprop (rtx, rtx, bool);
 static void local_cprop_pass (bool);
 static bool is_too_expensive (const char *);
 
+#define GNEW(T)			((T *) gmalloc (sizeof (T)))
+#define GCNEW(T)		((T *) gcalloc (1, sizeof (T)))
+
+#define GNEWVEC(T, N)		((T *) gmalloc (sizeof (T) * (N)))
+#define GCNEWVEC(T, N)		((T *) gcalloc ((N), sizeof (T)))
+#define GRESIZEVEC(T, P, N)	((T *) grealloc ((void *) (P), sizeof (T) * (N)))
+
+#define GNEWVAR(T, S)		((T *) gmalloc ((S)))
+#define GCNEWVAR(T, S)		((T *) gcalloc (1, (S)))
+#define GRESIZEVAR(T, P, S)	((T *) grealloc ((P), (S)))
+
+#define GOBNEW(T)		((T *) gcse_alloc (sizeof (T)))
+#define GOBNEWVAR(T, S)		((T *) gcse_alloc ((S)))
+
 
 /* Entry point for global common subexpression elimination.
    F is the first instruction in the function.  Return nonzero if a
@@ -698,7 +712,7 @@ gcse_main (rtx f ATTRIBUTE_UNUSED)
   pass = 0;
   initial_bytes_used = bytes_used;
   max_pass_bytes = 0;
-  gcse_obstack_bottom = gcse_alloc (1);
+  gcse_obstack_bottom = GOBNEWVAR (char, 1);
   changed = 1;
   while (changed && pass < MAX_GCSE_PASSES)
     {
@@ -736,8 +750,8 @@ gcse_main (rtx f ATTRIBUTE_UNUSED)
 	  if (changed)
 	    {
 	      free_modify_mem_tables ();
-	      modify_mem_list = gcalloc (last_basic_block, sizeof (rtx));
-	      canon_modify_mem_list = gcalloc (last_basic_block, sizeof (rtx));
+	      modify_mem_list = GCNEWVEC (rtx, last_basic_block);
+	      canon_modify_mem_list = GCNEWVEC (rtx, last_basic_block);
 	    }
 	  free_reg_set_mem ();
 	  alloc_reg_set_mem (max_reg_num ());
@@ -931,7 +945,7 @@ alloc_gcse_mem (void)
      but we should never see those anyway, so this is OK.)  */
 
   max_uid = get_max_uid ();
-  uid_cuid = gcalloc (max_uid + 1, sizeof (int));
+  uid_cuid = GCNEWVEC (int, max_uid + 1);
   i = 0;
   FOR_EACH_BB (bb)
     FOR_BB_INSNS (bb, insn)
@@ -951,8 +965,8 @@ alloc_gcse_mem (void)
   reg_set_in_block = sbitmap_vector_alloc (last_basic_block, max_gcse_regno);
   /* Allocate array to keep a list of insns which modify memory in each
      basic block.  */
-  modify_mem_list = gcalloc (last_basic_block, sizeof (rtx));
-  canon_modify_mem_list = gcalloc (last_basic_block, sizeof (rtx));
+  modify_mem_list = GCNEWVEC (rtx, last_basic_block);
+  canon_modify_mem_list = GCNEWVEC (rtx, last_basic_block);
   modify_mem_list_set = BITMAP_ALLOC (NULL);
   blocks_with_calls = BITMAP_ALLOC (NULL);
 }
@@ -1076,7 +1090,7 @@ static void
 alloc_reg_set_mem (int n_regs)
 {
   reg_set_table_size = n_regs + REG_SET_TABLE_SLOP;
-  reg_set_table = gcalloc (reg_set_table_size, sizeof (struct reg_set *));
+  reg_set_table = GCNEWVEC (struct reg_set *, reg_set_table_size);
 
   gcc_obstack_init (&reg_set_obstack);
 }
@@ -1101,14 +1115,13 @@ record_one_set (int regno, rtx insn)
     {
       int new_size = regno + REG_SET_TABLE_SLOP;
 
-      reg_set_table = grealloc (reg_set_table,
-				new_size * sizeof (struct reg_set *));
+      reg_set_table = GRESIZEVEC (struct reg_set *, reg_set_table, new_size);
       memset (reg_set_table + reg_set_table_size, 0,
 	      (new_size - reg_set_table_size) * sizeof (struct reg_set *));
       reg_set_table_size = new_size;
     }
 
-  new_reg_info = obstack_alloc (&reg_set_obstack, sizeof (struct reg_set));
+  new_reg_info = XOBNEW (&reg_set_obstack, struct reg_set);
   bytes_used += sizeof (struct reg_set);
   new_reg_info->bb_index = BLOCK_NUM (insn);
   new_reg_info->next = reg_set_table[regno];
@@ -1509,7 +1522,7 @@ insert_expr_in_table (rtx x, enum machine_mode mode, rtx insn, int antic_p,
 
   if (! found)
     {
-      cur_expr = gcse_alloc (sizeof (struct expr));
+      cur_expr = GOBNEW (struct expr);
       bytes_used += sizeof (struct expr);
       if (table->table[hash] == NULL)
 	/* This is the first pattern that hashed to this index.  */
@@ -1542,7 +1555,7 @@ insert_expr_in_table (rtx x, enum machine_mode mode, rtx insn, int antic_p,
       else
 	{
 	  /* First occurrence of this expression in this basic block.  */
-	  antic_occr = gcse_alloc (sizeof (struct occr));
+	  antic_occr = GOBNEW (struct occr);
 	  bytes_used += sizeof (struct occr);
 	  antic_occr->insn = insn;
 	  antic_occr->next = cur_expr->antic_occr;
@@ -1566,7 +1579,7 @@ insert_expr_in_table (rtx x, enum machine_mode mode, rtx insn, int antic_p,
       else
 	{
 	  /* First occurrence of this expression in this basic block.  */
-	  avail_occr = gcse_alloc (sizeof (struct occr));
+	  avail_occr = GOBNEW (struct occr);
 	  bytes_used += sizeof (struct occr);
 	  avail_occr->insn = insn;
 	  avail_occr->next = cur_expr->avail_occr;
@@ -1606,7 +1619,7 @@ insert_set_in_table (rtx x, rtx insn, struct hash_table *table)
 
   if (! found)
     {
-      cur_expr = gcse_alloc (sizeof (struct expr));
+      cur_expr = GOBNEW (struct expr);
       bytes_used += sizeof (struct expr);
       if (table->table[hash] == NULL)
 	/* This is the first pattern that hashed to this index.  */
@@ -1639,7 +1652,7 @@ insert_set_in_table (rtx x, rtx insn, struct hash_table *table)
   else
     {
       /* First occurrence of this expression in this basic block.  */
-      cur_occr = gcse_alloc (sizeof (struct occr));
+      cur_occr = GOBNEW (struct occr);
       bytes_used += sizeof (struct occr);
 
 	  cur_occr->insn = insn;
@@ -1878,8 +1891,8 @@ dump_hash_table (FILE *file, const char *name, struct hash_table *table)
   unsigned int *hash_val;
   struct expr *expr;
 
-  flat_table = xcalloc (table->n_elems, sizeof (struct expr *));
-  hash_val = xmalloc (table->n_elems * sizeof (unsigned int));
+  flat_table = XCNEWVEC (struct expr *, table->n_elems);
+  hash_val = XNEWVEC (unsigned int, table->n_elems);
 
   for (i = 0; i < (int) table->size; i++)
     for (expr = table->table[i]; expr != NULL; expr = expr->next_same_hash)
@@ -2048,7 +2061,7 @@ compute_hash_table_work (struct hash_table *table)
   /* re-Cache any INSN_LIST nodes we have allocated.  */
   clear_modify_mem_tables ();
   /* Some working arrays used to track first and last set in each block.  */
-  reg_avail_info = gmalloc (max_gcse_regno * sizeof (struct reg_avail_info));
+  reg_avail_info = GNEWVEC (struct reg_avail_info, max_gcse_regno);
 
   for (i = 0; i < max_gcse_regno; ++i)
     reg_avail_info[i].last_bb = NULL;
@@ -2116,7 +2129,7 @@ alloc_hash_table (int n_insns, struct hash_table *table, int set_p)
      ??? Later take some measurements.  */
   table->size |= 1;
   n = table->size * sizeof (struct expr *);
-  table->table = gmalloc (n);
+  table->table = GNEWVAR (struct expr *, n);
   table->set_p = set_p;
 }
 
@@ -4988,14 +5001,15 @@ static hashval_t
 pre_ldst_expr_hash (const void *p)
 {
   int do_not_record_p = 0;
-  const struct ls_expr *x = p;
+  const struct ls_expr *const x = (const struct ls_expr *) p;
   return hash_rtx (x->pattern, GET_MODE (x->pattern), &do_not_record_p, NULL, false);
 }
 
 static int
 pre_ldst_expr_eq (const void *p1, const void *p2)
 {
-  const struct ls_expr *ptr1 = p1, *ptr2 = p2;
+  const struct ls_expr *const ptr1 = (const struct ls_expr *) p1,
+    *const ptr2 = (const struct ls_expr *) p2;
   return expr_equiv_p (ptr1->pattern, ptr2->pattern);
 }
 
@@ -5117,7 +5131,7 @@ find_rtx_in_ldst (rtx x)
   slot = htab_find_slot (pre_ldst_table, &e, NO_INSERT);
   if (!slot || ((struct ls_expr *)*slot)->invalid)
     return NULL;
-  return *slot;
+  return (struct ls_expr *) *slot;
 }
 
 /* Assign each element of the list of mems a monotonically increasing value.  */
@@ -5425,7 +5439,7 @@ static void
 reg_set_info (rtx dest, const_rtx setter ATTRIBUTE_UNUSED,
 	      void *data)
 {
-  sbitmap bb_reg = data;
+  sbitmap bb_reg = (sbitmap) data;
 
   if (GET_CODE (dest) == SUBREG)
     dest = SUBREG_REG (dest);
@@ -5445,7 +5459,7 @@ static void
 reg_clear_last_set (rtx dest, const_rtx setter ATTRIBUTE_UNUSED,
 	      void *data)
 {
-  int *dead_vec = data;
+  int *dead_vec = (int *) data;
 
   if (GET_CODE (dest) == SUBREG)
     dest = SUBREG_REG (dest);