diff --git a/gcc/ChangeLog b/gcc/ChangeLog
index 06d976847a3..4c2a7f89bb6 100644
--- a/gcc/ChangeLog
+++ b/gcc/ChangeLog
@@ -1,3 +1,31 @@
+2000-11-07  Joseph S. Myers  <jsm28@cam.ac.uk>
+
+	* alias.c (init_alias_analysis), calls.c (expand_call,
+	emit_library_call_value_1), combine.c (init_reg_last_arrays),
+	cse.c (new_basic_block), dbxout.c (dbxout_type), diagnostic.c
+	(init_output_buffer, set_diagnostic_context), dwarf2out.c
+	(equate_decl_number_to_die, build_abbrev_table), emit-rtl.c
+	(init_emit_once), fold-const.c (mul_double, div_and_round_double),
+	function.c (assign_parms), gcse.c (compute_can_copy,
+	alloc_gcse_mem, alloc_reg_set_mem, record_one_set,
+	compute_hash_table, compute_set_hash_table,
+	compute_expr_hash_table), genattrtab.c (optimize_attrs), global.c
+	(global_alloc, global_conflicts), haifa-sched.c (compute_trg_info,
+	clear_units, schedule_block), integrate.c (initialize_for_inline,
+	expand_inline_function), jump.c (thread_jumps), local-alloc.c
+	(local_alloc), loop.c (combine_movables, count_loop_regs_set,
+	load_mems_and_recount_loop_regs_set), print-tree.c (debug_tree),
+	regclass.c (init_reg_sets, init_reg_sets_1, regclass,
+	record_reg_classes, allocate_reg_info), reload.c
+	(get_secondary_mem, remove_address_replacements, find_reloads),
+	reload1.c (reload, set_initial_label_offsets, finish_spills,
+	reload_as_needed, choose_reload_regs_init,
+	reload_cse_simplify_operands), reorg.c (dbr_schedule), sbitmap.c
+	(sbitmap_zero), simplify-rtx.c (simplify_plus_minus), ssa.c
+	(rename_registers), stmt.c (expand_end_case), unroll.c
+	(unroll_loop), varray.c (varray_grow), objc/objc-act.c: Use memset
+	() instead of bzero ().
+
 2000-11-07  Neil Booth  <neilb@earthling.net>
 
        * cp/lang-specs.h: Fix -save-temps specs under USE_CPPLIB.
diff --git a/gcc/alias.c b/gcc/alias.c
index 28016d3245a..e9e30ee8744 100644
--- a/gcc/alias.c
+++ b/gcc/alias.c
@@ -2053,7 +2053,7 @@ init_alias_analysis ()
       /* ??? Why are we realloc'ing if we're just going to zero it?  */
       alias_invariant = (rtx *)xrealloc (alias_invariant,
 					 reg_base_value_size * sizeof (rtx));
-      bzero ((char *)alias_invariant, reg_base_value_size * sizeof (rtx));
+      memset ((char *)alias_invariant, 0, reg_base_value_size * sizeof (rtx));
     }
     
 
@@ -2091,10 +2091,10 @@ init_alias_analysis ()
       copying_arguments = 1;
 
       /* Wipe the potential alias information clean for this pass.  */
-      bzero ((char *) new_reg_base_value, reg_base_value_size * sizeof (rtx));
+      memset ((char *) new_reg_base_value, 0, reg_base_value_size * sizeof (rtx));
 
       /* Wipe the reg_seen array clean.  */
-      bzero ((char *) reg_seen, reg_base_value_size);
+      memset ((char *) reg_seen, 0, reg_base_value_size);
 
       /* Mark all hard registers which may contain an address.
 	 The stack, frame and argument pointers may contain an address.
diff --git a/gcc/calls.c b/gcc/calls.c
index 09f08e4027a..ec0ad09666b 100644
--- a/gcc/calls.c
+++ b/gcc/calls.c
@@ -2376,7 +2376,7 @@ expand_call (exp, target, ignore)
 
   /* Make a vector to hold all the information about each arg.  */
   args = (struct arg_data *) alloca (num_actuals * sizeof (struct arg_data));
-  bzero ((char *) args, num_actuals * sizeof (struct arg_data));
+  memset ((char *) args, 0, num_actuals * sizeof (struct arg_data));
 
   /* Build up entries inthe ARGS array, compute the size of the arguments
      into ARGS_SIZE, etc.  */
@@ -2786,7 +2786,7 @@ expand_call (exp, target, ignore)
 			   initial_highest_arg_in_use);
 
 		  if (initial_highest_arg_in_use != highest_outgoing_arg_in_use)
-		    bzero (&stack_usage_map[initial_highest_arg_in_use],
+		    memset (&stack_usage_map[initial_highest_arg_in_use], 0,
 			   (highest_outgoing_arg_in_use
 			    - initial_highest_arg_in_use));
 		  needed = 0;
@@ -2875,7 +2875,7 @@ expand_call (exp, target, ignore)
 			  /* Make a new map for the new argument list.  */
 			  stack_usage_map = (char *)
 			    alloca (highest_outgoing_arg_in_use);
-			  bzero (stack_usage_map, highest_outgoing_arg_in_use);
+			  memset (stack_usage_map, 0, highest_outgoing_arg_in_use);
 			  highest_outgoing_arg_in_use = 0;
 			}
 		      allocate_dynamic_stack_space (push_size, NULL_RTX,
@@ -3577,7 +3577,7 @@ emit_library_call_value_1 (retval, orgfun, value, fn_type, outmode, nargs, p)
      library functions shouldn't have many args.  */
 
   argvec = (struct arg *) alloca ((nargs + 1) * sizeof (struct arg));
-  bzero ((char *) argvec, (nargs + 1) * sizeof (struct arg));
+  memset ((char *) argvec, 0, (nargs + 1) * sizeof (struct arg));
 
   INIT_CUMULATIVE_ARGS (args_so_far, NULL_TREE, fun, 0);
 
@@ -3770,7 +3770,7 @@ emit_library_call_value_1 (retval, orgfun, value, fn_type, outmode, nargs, p)
 	       initial_highest_arg_in_use);
 
       if (initial_highest_arg_in_use != highest_outgoing_arg_in_use)
-	bzero (&stack_usage_map[initial_highest_arg_in_use],
+	memset (&stack_usage_map[initial_highest_arg_in_use], 0,
 	       highest_outgoing_arg_in_use - initial_highest_arg_in_use);
       needed = 0;
 
diff --git a/gcc/ch/ChangeLog b/gcc/ch/ChangeLog
index fb5d21b0127..c8d57666160 100644
--- a/gcc/ch/ChangeLog
+++ b/gcc/ch/ChangeLog
@@ -1,3 +1,8 @@
+2000-11-07  Joseph S. Myers  <jsm28@cam.ac.uk>
+
+	* actions.c (check_missing_cases), typeck.c (build_chill_slice,
+	build_chill_cast): Use memset () instead of bzero ().
+
 2000-11-05  Joseph S. Myers  <jsm28@cam.ac.uk>
 
 	* Make-lang.in (CHILL.distdir): Remove.
diff --git a/gcc/ch/actions.c b/gcc/ch/actions.c
index 32bb18152ad..09c8a5a23f7 100644
--- a/gcc/ch/actions.c
+++ b/gcc/ch/actions.c
@@ -1464,7 +1464,7 @@ check_missing_cases (type)
     warning ("too many cases to do CASE completeness testing");
   else
     {
-      bzero (cases_seen, bytes_needed);
+      memset (cases_seen, 0, bytes_needed);
       mark_seen_cases (type, cases_seen, size, is_sparse);
       print_missing_cases (type, cases_seen, size);
       free (cases_seen);
diff --git a/gcc/ch/typeck.c b/gcc/ch/typeck.c
index 7c4f554e7de..ef4a2e3bae6 100644
--- a/gcc/ch/typeck.c
+++ b/gcc/ch/typeck.c
@@ -253,7 +253,7 @@ build_chill_slice (array, min_value, length)
 		       * (tree_low_cst (min_value, 0)
 			  - tree_low_cst (domain_min, 0)));
 
-	  bzero (buffer, type_size);
+	  memset (buffer, 0, type_size);
 	  if (expand_constant_to_buffer (array, buffer, type_size))
 	    {
 	      result = extract_constant_from_buffer (slice_type,
@@ -1193,7 +1193,7 @@ build_chill_cast (type, expr)
     {
       unsigned char *buffer = (unsigned char*) alloca (type_size);
       tree value;
-      bzero (buffer, type_size);
+      memset (buffer, 0, type_size);
       if (!expand_constant_to_buffer (expr, buffer, type_size))
 	{
 	  error ("not implemented: constant conversion from that kind of expression");
diff --git a/gcc/combine.c b/gcc/combine.c
index 63738958f01..18c532238b6 100644
--- a/gcc/combine.c
+++ b/gcc/combine.c
@@ -789,15 +789,15 @@ init_reg_last_arrays ()
 {
   unsigned int nregs = combine_max_regno;
 
-  bzero ((char *) reg_last_death, nregs * sizeof (rtx));
-  bzero ((char *) reg_last_set, nregs * sizeof (rtx));
-  bzero ((char *) reg_last_set_value, nregs * sizeof (rtx));
-  bzero ((char *) reg_last_set_table_tick, nregs * sizeof (int));
-  bzero ((char *) reg_last_set_label, nregs * sizeof (int));
-  bzero (reg_last_set_invalid, nregs * sizeof (char));
-  bzero ((char *) reg_last_set_mode, nregs * sizeof (enum machine_mode));
-  bzero ((char *) reg_last_set_nonzero_bits, nregs * sizeof (HOST_WIDE_INT));
-  bzero (reg_last_set_sign_bit_copies, nregs * sizeof (char));
+  memset ((char *) reg_last_death, 0, nregs * sizeof (rtx));
+  memset ((char *) reg_last_set, 0, nregs * sizeof (rtx));
+  memset ((char *) reg_last_set_value, 0, nregs * sizeof (rtx));
+  memset ((char *) reg_last_set_table_tick, 0, nregs * sizeof (int));
+  memset ((char *) reg_last_set_label, 0, nregs * sizeof (int));
+  memset (reg_last_set_invalid, 0, nregs * sizeof (char));
+  memset ((char *) reg_last_set_mode, 0, nregs * sizeof (enum machine_mode));
+  memset ((char *) reg_last_set_nonzero_bits, 0, nregs * sizeof (HOST_WIDE_INT));
+  memset (reg_last_set_sign_bit_copies, 0, nregs * sizeof (char));
 }
 
 /* Set up any promoted values for incoming argument registers.  */
diff --git a/gcc/cp/ChangeLog b/gcc/cp/ChangeLog
index 62edaf5401c..d11ff26ff2d 100644
--- a/gcc/cp/ChangeLog
+++ b/gcc/cp/ChangeLog
@@ -1,3 +1,10 @@
+2000-11-07  Joseph S. Myers  <jsm28@cam.ac.uk>
+
+	* class.c (duplicate_tag_error, build_vtbl_initializer), decl.c
+	(push_binding_level), error.c (cp_tree_printer), pt.c
+	(process_partial_specialization, tsubst_template_arg_vector),
+	search.c (lookup_member): Use memset () instead of bzero ().
+
 2000-11-07  Nathan Sidwell  <nathan@codesourcery.com>
 
 	* decl.c (build_ptrmemfunc_type): Allow error_mark_node.
diff --git a/gcc/cp/class.c b/gcc/cp/class.c
index 8ddc4749d83..ff6f34cf15d 100644
--- a/gcc/cp/class.c
+++ b/gcc/cp/class.c
@@ -2351,7 +2351,7 @@ duplicate_tag_error (t)
       tree template_info = CLASSTYPE_TEMPLATE_INFO (t);
       int use_template = CLASSTYPE_USE_TEMPLATE (t);
 
-      bzero ((char *) TYPE_LANG_SPECIFIC (t), sizeof (struct lang_type));
+      memset ((char *) TYPE_LANG_SPECIFIC (t), 0, sizeof (struct lang_type));
       BINFO_BASETYPES(binfo) = NULL_TREE;
 
       TYPE_BINFO (t) = binfo;
@@ -7231,7 +7231,7 @@ build_vtbl_initializer (binfo, orig_binfo, t, rtti_binfo, non_fn_entries_p)
   vtbl_init_data vid;
 
   /* Initialize VID.  */
-  bzero (&vid, sizeof (vid));
+  memset (&vid, 0, sizeof (vid));
   vid.binfo = binfo;
   vid.derived = t;
   vid.last_init = &vid.inits;
diff --git a/gcc/cp/decl.c b/gcc/cp/decl.c
index f4d170a9f30..335672006cf 100644
--- a/gcc/cp/decl.c
+++ b/gcc/cp/decl.c
@@ -566,7 +566,7 @@ push_binding_level (newlevel, tag_transparent, keep)
 {
   /* Add this level to the front of the chain (stack) of levels that
      are active.  */
-  bzero ((char*) newlevel, sizeof (struct binding_level));
+  memset ((char*) newlevel, 0, sizeof (struct binding_level));
   newlevel->level_chain = current_binding_level;
   current_binding_level = newlevel;
   newlevel->tag_transparent = tag_transparent;
diff --git a/gcc/cp/error.c b/gcc/cp/error.c
index 9fbd8a73007..9717ce03112 100644
--- a/gcc/cp/error.c
+++ b/gcc/cp/error.c
@@ -2650,7 +2650,7 @@ cp_tree_printer (buffer)
   int be_verbose = 0;
   tree_formatting_info tfi;
 
-  bzero (&tfi, sizeof (tree_formatting_info));
+  memset (&tfi, 0, sizeof (tree_formatting_info));
 
   if (*output_buffer_text_cursor (buffer) == '+')
     ++output_buffer_text_cursor (buffer);
diff --git a/gcc/cp/pt.c b/gcc/cp/pt.c
index 9465a1d7c12..7098d7d298a 100644
--- a/gcc/cp/pt.c
+++ b/gcc/cp/pt.c
@@ -2108,10 +2108,10 @@ process_partial_specialization (decl)
      or some such would have been OK.  */
   tpd.level = TMPL_PARMS_DEPTH (current_template_parms);
   tpd.parms = alloca (sizeof (int) * ntparms);
-  bzero ((PTR) tpd.parms, sizeof (int) * ntparms);
+  memset ((PTR) tpd.parms, 0, sizeof (int) * ntparms);
 
   tpd.arg_uses_template_parms = alloca (sizeof (int) * nargs);
-  bzero ((PTR) tpd.arg_uses_template_parms, sizeof (int) * nargs);
+  memset ((PTR) tpd.arg_uses_template_parms, 0, sizeof (int) * nargs);
   for (i = 0; i < nargs; ++i)
     {
       tpd.current_arg = i;
@@ -2195,7 +2195,7 @@ process_partial_specialization (decl)
 		 template, not in the specialization.  */
 	      tpd2.current_arg = i;
 	      tpd2.arg_uses_template_parms[i] = 0;
-	      bzero ((PTR) tpd2.parms, sizeof (int) * nargs);
+	      memset ((PTR) tpd2.parms, 0, sizeof (int) * nargs);
 	      for_each_template_parm (type,
 				      &mark_template_parm,
 				      &tpd2);
@@ -5195,7 +5195,7 @@ tsubst_template_arg_vector (t, args, complain)
   int len = TREE_VEC_LENGTH (t), need_new = 0, i;
   tree *elts = (tree *) alloca (len * sizeof (tree));
   
-  bzero ((char *) elts, len * sizeof (tree));
+  memset ((char *) elts, 0, len * sizeof (tree));
   
   for (i = 0; i < len; i++)
     {
diff --git a/gcc/cp/search.c b/gcc/cp/search.c
index 67f16fb1918..a7fdc86888b 100644
--- a/gcc/cp/search.c
+++ b/gcc/cp/search.c
@@ -1538,7 +1538,7 @@ lookup_member (xbasetype, name, protect, want_type)
   n_calls_lookup_field++;
 #endif /* GATHER_STATISTICS */
 
-  bzero ((PTR) &lfi, sizeof (lfi));
+  memset ((PTR) &lfi, 0, sizeof (lfi));
   lfi.type = type;
   lfi.name = name;
   lfi.want_type = want_type;
diff --git a/gcc/cse.c b/gcc/cse.c
index 17d35ceff76..d36816a2e81 100644
--- a/gcc/cse.c
+++ b/gcc/cse.c
@@ -993,7 +993,7 @@ new_basic_block ()
 
   /* Clear out hash table state for this pass.  */
 
-  bzero ((char *) reg_hash, sizeof reg_hash);
+  memset ((char *) reg_hash, 0, sizeof reg_hash);
 
   if (cse_reg_info_used_list)
     {
diff --git a/gcc/dbxout.c b/gcc/dbxout.c
index 7da5ad87801..f25eb347ac5 100644
--- a/gcc/dbxout.c
+++ b/gcc/dbxout.c
@@ -1043,7 +1043,7 @@ dbxout_type (type, full, show_arg_types)
 	  typevec
 	    = (struct typeinfo *) xrealloc (typevec,
 					    typevec_len * 2 * sizeof typevec[0]);
-	  bzero ((char *) (typevec + typevec_len),
+	  memset ((char *) (typevec + typevec_len), 0,
 		 typevec_len * sizeof typevec[0]);
 	  typevec_len *= 2;
 	}
diff --git a/gcc/diagnostic.c b/gcc/diagnostic.c
index 5d6d1c88d5a..c2fe71a912c 100644
--- a/gcc/diagnostic.c
+++ b/gcc/diagnostic.c
@@ -331,7 +331,7 @@ init_output_buffer (buffer, prefix, maximum_length)
      const char *prefix;
      int maximum_length;
 {
-  bzero (buffer, sizeof (output_buffer));
+  memset (buffer, 0, sizeof (output_buffer));
   obstack_init (&buffer->obstack);
   ideal_line_wrap_cutoff (buffer) = maximum_length;
   prefixing_policy (buffer) = current_prefixing_rule;
@@ -1692,7 +1692,7 @@ set_diagnostic_context (dc, message, args_ptr, file, line, warn)
      int line;
      int warn;
 {
-  bzero (dc, sizeof (diagnostic_context));
+  memset (dc, 0, sizeof (diagnostic_context));
   diagnostic_message (dc) = message;
   diagnostic_argument_list (dc) = args_ptr;
   diagnostic_file_location (dc) = file;
diff --git a/gcc/dwarf2out.c b/gcc/dwarf2out.c
index 77de3a9b769..507c9a7d3e3 100644
--- a/gcc/dwarf2out.c
+++ b/gcc/dwarf2out.c
@@ -4849,7 +4849,7 @@ equate_decl_number_to_die (decl, decl_die)
 	= (dw_die_ref *) xrealloc (decl_die_table,
 				   sizeof (dw_die_ref) * num_allocated);
 
-      bzero ((char *) &decl_die_table[decl_die_table_allocated],
+      memset ((char *) &decl_die_table[decl_die_table_allocated], 0,
 	     (num_allocated - decl_die_table_allocated) * sizeof (dw_die_ref));
       decl_die_table_allocated = num_allocated;
     }
@@ -5481,7 +5481,7 @@ build_abbrev_table (die)
 	    = (dw_die_ref *) xrealloc (abbrev_die_table,
 				       sizeof (dw_die_ref) * n_alloc);
 
-	  bzero ((char *) &abbrev_die_table[abbrev_die_table_allocated],
+	  memset ((char *) &abbrev_die_table[abbrev_die_table_allocated], 0,
 		 (n_alloc - abbrev_die_table_allocated) * sizeof (dw_die_ref));
 	  abbrev_die_table_allocated = n_alloc;
 	}
diff --git a/gcc/emit-rtl.c b/gcc/emit-rtl.c
index 3929e8820cf..c73b346fe5b 100644
--- a/gcc/emit-rtl.c
+++ b/gcc/emit-rtl.c
@@ -4106,7 +4106,7 @@ init_emit_once (line_numbers)
 	  rtx tem = rtx_alloc (CONST_DOUBLE);
 	  union real_extract u;
 
-	  bzero ((char *) &u, sizeof u);  /* Zero any holes in a structure.  */
+	  memset ((char *) &u, 0, sizeof u);  /* Zero any holes in a structure.  */
 	  u.d = i == 0 ? dconst0 : i == 1 ? dconst1 : dconst2;
 
 	  bcopy ((char *) &u, (char *) &CONST_DOUBLE_LOW (tem), sizeof u);
diff --git a/gcc/fold-const.c b/gcc/fold-const.c
index 58d84ef3dd9..da27f470f1e 100644
--- a/gcc/fold-const.c
+++ b/gcc/fold-const.c
@@ -325,7 +325,7 @@ mul_double (l1, h1, l2, h2, lv, hv)
   encode (arg1, l1, h1);
   encode (arg2, l2, h2);
 
-  bzero ((char *) prod, sizeof prod);
+  memset ((char *) prod, 0, sizeof prod);
 
   for (i = 0; i < 4; i++)
     {
@@ -577,10 +577,10 @@ div_and_round_double (code, uns,
       goto finish_up;
     }
 
-  bzero ((char *) quo, sizeof quo);
+  memset ((char *) quo, 0, sizeof quo);
 
-  bzero ((char *) num, sizeof num);	/* to zero 9th element */
-  bzero ((char *) den, sizeof den);
+  memset ((char *) num, 0, sizeof num);	/* to zero 9th element */
+  memset ((char *) den, 0, sizeof den);
 
   encode (num, lnum, hnum);
   encode (den, lden, hden);
diff --git a/gcc/function.c b/gcc/function.c
index c7ff587394c..f86521a2eb6 100644
--- a/gcc/function.c
+++ b/gcc/function.c
@@ -4787,7 +4787,7 @@ assign_parms (fndecl)
 	      max_parm_reg = regno + 1;
 	      new = (rtx *) xrealloc (parm_reg_stack_loc,
 				      max_parm_reg * sizeof (rtx));
-	      bzero ((char *) (new + old_max_parm_reg),
+	      memset ((char *) (new + old_max_parm_reg), 0,
 		     (max_parm_reg - old_max_parm_reg) * sizeof (rtx));
 	      parm_reg_stack_loc = new;
 	    }
diff --git a/gcc/gcse.c b/gcc/gcse.c
index 484eb1a16c6..29385972923 100644
--- a/gcc/gcse.c
+++ b/gcc/gcse.c
@@ -817,7 +817,7 @@ compute_can_copy ()
 #ifndef AVOID_CCMODE_COPIES
   rtx reg,insn;
 #endif
-  bzero (can_copy_p, NUM_MACHINE_MODES);
+  memset (can_copy_p, 0, NUM_MACHINE_MODES);
 
   start_sequence ();
   for (i = 0; i < NUM_MACHINE_MODES; i++)
@@ -890,7 +890,7 @@ alloc_gcse_mem (f)
   max_uid = get_max_uid ();
   n = (max_uid + 1) * sizeof (int);
   uid_cuid = (int *) gmalloc (n);
-  bzero ((char *) uid_cuid, n);
+  memset ((char *) uid_cuid, 0, n);
   for (insn = f, i = 0; insn; insn = NEXT_INSN (insn))
     {
       if (INSN_P (insn))
@@ -904,7 +904,7 @@ alloc_gcse_mem (f)
   max_cuid = i;
   n = (max_cuid + 1) * sizeof (rtx);
   cuid_insn = (rtx *) gmalloc (n);
-  bzero ((char *) cuid_insn, n);
+  memset ((char *) cuid_insn, 0, n);
   for (insn = f, i = 0; insn; insn = NEXT_INSN (insn))
     if (INSN_P (insn))
       CUID_INSN (i++) = insn;
@@ -1095,7 +1095,7 @@ alloc_reg_set_mem (n_regs)
   reg_set_table_size = n_regs + REG_SET_TABLE_SLOP;
   n = reg_set_table_size * sizeof (struct reg_set *);
   reg_set_table = (struct reg_set **) gmalloc (n);
-  bzero ((char *) reg_set_table, n);
+  memset ((char *) reg_set_table, 0, n);
 
   gcc_obstack_init (&reg_set_obstack);
 }
@@ -1125,7 +1125,7 @@ record_one_set (regno, insn)
       reg_set_table
 	= (struct reg_set **) grealloc ((char *) reg_set_table,
 					new_size * sizeof (struct reg_set *));
-      bzero ((char *) (reg_set_table + reg_set_table_size),
+      memset ((char *) (reg_set_table + reg_set_table_size), 0,
 	     (new_size - reg_set_table_size) * sizeof (struct reg_set *));
       reg_set_table_size = new_size;
     }
@@ -2154,7 +2154,7 @@ compute_hash_table (set_p)
      ??? This isn't needed during const/copy propagation, but it's cheap to
      compute.  Later.  */
   sbitmap_vector_zero (reg_set_in_block, n_basic_blocks);
-  bzero ((char *) mem_set_in_block, n_basic_blocks);
+  memset ((char *) mem_set_in_block, 0, n_basic_blocks);
 
   /* Some working arrays used to track first and last set in each block.  */
   /* ??? One could use alloca here, but at some size a threshold is crossed
@@ -2282,7 +2282,7 @@ compute_set_hash_table ()
 {
   /* Initialize count of number of entries in hash table.  */
   n_sets = 0;
-  bzero ((char *) set_hash_table,
+  memset ((char *) set_hash_table, 0,
 	 set_hash_table_size * sizeof (struct expr *));
 
   compute_hash_table (1);
@@ -2326,7 +2326,7 @@ compute_expr_hash_table ()
 {
   /* Initialize count of number of entries in hash table.  */
   n_exprs = 0;
-  bzero ((char *) expr_hash_table,
+  memset ((char *) expr_hash_table, 0,
 	 expr_hash_table_size * sizeof (struct expr *));
 
   compute_hash_table (0);
diff --git a/gcc/genattrtab.c b/gcc/genattrtab.c
index 0796a1b39dd..d3f77b0640d 100644
--- a/gcc/genattrtab.c
+++ b/gcc/genattrtab.c
@@ -3459,7 +3459,7 @@ optimize_attrs ()
   insn_code_values
     = (struct attr_value_list **) alloca ((insn_code_number + 2)
 					  * sizeof (struct attr_value_list *));
-  bzero ((char *) insn_code_values,
+  memset ((char *) insn_code_values, 0,
 	 (insn_code_number + 2) * sizeof (struct attr_value_list *));
 
   /* Offset the table address so we can index by -2 or -1.  */
diff --git a/gcc/global.c b/gcc/global.c
index 7f426df38f6..54d18c80d23 100644
--- a/gcc/global.c
+++ b/gcc/global.c
@@ -454,8 +454,8 @@ global_alloc (file)
   /* Calculate amount of usage of each hard reg by pseudos
      allocated by local-alloc.  This is to see if we want to
      override it.  */
-  bzero ((char *) local_reg_live_length, sizeof local_reg_live_length);
-  bzero ((char *) local_reg_n_refs, sizeof local_reg_n_refs);
+  memset ((char *) local_reg_live_length, 0, sizeof local_reg_live_length);
+  memset ((char *) local_reg_n_refs, 0, sizeof local_reg_n_refs);
   for (i = FIRST_PSEUDO_REGISTER; i < (size_t) max_regno; i++)
     if (reg_renumber[i] >= 0)
       {
@@ -637,7 +637,7 @@ global_conflicts ()
 
   for (b = 0; b < n_basic_blocks; b++)
     {
-      bzero ((char *) allocnos_live, allocno_row_words * sizeof (INT_TYPE));
+      memset ((char *) allocnos_live, 0, allocno_row_words * sizeof (INT_TYPE));
 
       /* Initialize table of registers currently live
 	 to the state at the beginning of this basic block.
diff --git a/gcc/haifa-sched.c b/gcc/haifa-sched.c
index e85cd200ce6..2ab6377d753 100644
--- a/gcc/haifa-sched.c
+++ b/gcc/haifa-sched.c
@@ -2054,7 +2054,7 @@ compute_trg_info (trg)
 	     up with a lot of duplicates.  We need to weed them out to avoid
 	     overrunning the end of the bblst_table.  */
 	  update_blocks = (char *) alloca (n_basic_blocks);
-	  bzero (update_blocks, n_basic_blocks);
+	  memset (update_blocks, 0, n_basic_blocks);
 
 	  update_idx = 0;
 	  for (j = 0; j < el.nr_members; j++)
@@ -2917,9 +2917,9 @@ static int unit_n_insns[FUNCTION_UNITS_SIZE];
 static void
 clear_units ()
 {
-  bzero ((char *) unit_last_insn, sizeof (unit_last_insn));
-  bzero ((char *) unit_tick, sizeof (unit_tick));
-  bzero ((char *) unit_n_insns, sizeof (unit_n_insns));
+  memset ((char *) unit_last_insn, 0, sizeof (unit_last_insn));
+  memset ((char *) unit_tick, 0, sizeof (unit_tick));
+  memset ((char *) unit_n_insns, 0, sizeof (unit_n_insns));
 }
 
 /* Return the issue-delay of an insn.  */
@@ -6019,7 +6019,7 @@ schedule_block (bb, rgn_n_insns)
   q_ptr = 0;
   q_size = 0;
   last_clock_var = 0;
-  bzero ((char *) insn_queue, sizeof (insn_queue));
+  memset ((char *) insn_queue, 0, sizeof (insn_queue));
 
   /* Start just before the beginning of time.  */
   clock_var = -1;
diff --git a/gcc/integrate.c b/gcc/integrate.c
index 8bf949bb28a..34aa4bff971 100644
--- a/gcc/integrate.c
+++ b/gcc/integrate.c
@@ -275,7 +275,7 @@ initialize_for_inline (fndecl)
   tree parms;
 
   /* Clear out PARMDECL_MAP.  It was allocated in the caller's frame.  */
-  bzero ((char *) parmdecl_map, max_parm_reg * sizeof (tree));
+  memset ((char *) parmdecl_map, 0, max_parm_reg * sizeof (tree));
   arg_vector = rtvec_alloc (list_length (DECL_ARGUMENTS (fndecl)));
 
   for (parms = DECL_ARGUMENTS (fndecl), i = 0;
@@ -1094,7 +1094,7 @@ expand_inline_function (fndecl, parms, target, ignore, type,
 
   /* Initialize label_map.  get_label_from_map will actually make
      the labels.  */
-  bzero ((char *) &map->label_map[min_labelno],
+  memset ((char *) &map->label_map[min_labelno], 0,
 	 (max_labelno - min_labelno) * sizeof (rtx));
 
   /* Make copies of the decls of the symbols in the inline function, so that
diff --git a/gcc/java/ChangeLog b/gcc/java/ChangeLog
index 46fe17d1df2..f4eff5346c3 100644
--- a/gcc/java/ChangeLog
+++ b/gcc/java/ChangeLog
@@ -1,3 +1,9 @@
+2000-11-07  Joseph S. Myers  <jsm28@cam.ac.uk>
+
+	* expr.c (note_instructions), jcf-io.c (find_class), jcf-parse.c
+	(init_outgoing_cpool), lex.c (java_init_lex): Use memset ()
+	instead of bzero ().
+
 2000-11-05  Tom Tromey  <tromey@cygnus.com>
 
 	* lex.h (JAVA_FLOAT_RANGE_ERROR): Typo fix.
diff --git a/gcc/java/expr.c b/gcc/java/expr.c
index 286fa6a7ba3..2d592299f30 100644
--- a/gcc/java/expr.c
+++ b/gcc/java/expr.c
@@ -2507,7 +2507,7 @@ note_instructions (jcf, method)
   JCF_SEEK (jcf, DECL_CODE_OFFSET (method));
   byte_ops = jcf->read_ptr;
   instruction_bits = xrealloc (instruction_bits, length + 1);
-  bzero (instruction_bits, length + 1);
+  memset (instruction_bits, 0, length + 1);
 
   /* This pass figures out which PC can be the targets of jumps. */
   for (PC = 0; PC < length;)
diff --git a/gcc/java/jcf-io.c b/gcc/java/jcf-io.c
index db192082881..03ea7d75acf 100644
--- a/gcc/java/jcf-io.c
+++ b/gcc/java/jcf-io.c
@@ -319,7 +319,7 @@ DEFUN(find_class, (classname, classname_length, jcf, source_ok),
      null pointer when we're copying it below.  */
   int buflen = jcf_path_max_len () + classname_length + 10;
   char *buffer = (char *) ALLOC (buflen);
-  bzero (buffer, buflen);
+  memset (buffer, 0, buflen);
 
   java_buffer = (char *) alloca (buflen);
 
diff --git a/gcc/java/jcf-parse.c b/gcc/java/jcf-parse.c
index 30fc4a4b526..090120a1c6c 100644
--- a/gcc/java/jcf-parse.c
+++ b/gcc/java/jcf-parse.c
@@ -648,7 +648,7 @@ init_outgoing_cpool ()
 {
   current_constant_pool_data_ref = NULL_TREE;
   outgoing_cpool = (struct CPool *)xmalloc (sizeof (struct CPool));
-  bzero (outgoing_cpool, sizeof (struct CPool));
+  memset (outgoing_cpool, 0, sizeof (struct CPool));
 }
 
 static void
diff --git a/gcc/java/lex.c b/gcc/java/lex.c
index be1fcf8e76f..1b8898c604c 100644
--- a/gcc/java/lex.c
+++ b/gcc/java/lex.c
@@ -115,8 +115,8 @@ java_init_lex (finput, encoding)
   CPC_INITIALIZER_LIST (ctxp) = CPC_STATIC_INITIALIZER_LIST (ctxp) =
     CPC_INSTANCE_INITIALIZER_LIST (ctxp) = ctxp->incomplete_class = NULL_TREE;
 
-  bzero ((PTR) ctxp->modifier_ctx, 11*sizeof (ctxp->modifier_ctx[0]));
-  bzero ((PTR) current_jcf, sizeof (JCF));
+  memset ((PTR) ctxp->modifier_ctx, 0, 11*sizeof (ctxp->modifier_ctx[0]));
+  memset ((PTR) current_jcf, 0, sizeof (JCF));
   ctxp->current_parsed_class = NULL;
   ctxp->package = NULL_TREE;
 #endif
diff --git a/gcc/jump.c b/gcc/jump.c
index 8574f161526..4c9c5ea2fae 100644
--- a/gcc/jump.c
+++ b/gcc/jump.c
@@ -3745,7 +3745,7 @@ thread_jumps (f, max_reg, flag_before_loop)
 	      || ! any_condjump_p (b1) || JUMP_LABEL (b1) == 0)
 	    continue;
 
-	  bzero (modified_regs, max_reg * sizeof (char));
+	  memset (modified_regs, 0, max_reg * sizeof (char));
 	  modified_mem = 0;
 
 	  bcopy ((char *) all_reset, (char *) same_regs,
diff --git a/gcc/local-alloc.c b/gcc/local-alloc.c
index 2d7cac8f01f..2315338756b 100644
--- a/gcc/local-alloc.c
+++ b/gcc/local-alloc.c
@@ -411,7 +411,7 @@ local_alloc ()
       else
 	{
 #define CLEAR(vector)  \
-	  bzero ((char *) (vector), (sizeof (*(vector))) * next_qty);
+	  memset ((char *) (vector), 0, (sizeof (*(vector))) * next_qty);
 
 	  CLEAR (qty_phys_copy_sugg);
 	  CLEAR (qty_phys_num_copy_sugg);
diff --git a/gcc/loop.c b/gcc/loop.c
index f991c4965a8..9254fc90f56 100644
--- a/gcc/loop.c
+++ b/gcc/loop.c
@@ -1344,7 +1344,7 @@ combine_movables (movables, regs)
 	register struct movable *m1;
 	int regno = m->regno;
 
-	bzero (matched_regs, regs->num);
+	memset (matched_regs, 0, regs->num);
 	matched_regs[regno] = 1;
 
 	/* We want later insns to match the first one.  Don't make the first
@@ -3367,7 +3367,7 @@ count_loop_regs_set (loop, may_not_move, single_usage, count_ptr, nregs)
 	}
 
       if (GET_CODE (insn) == CODE_LABEL || GET_CODE (insn) == JUMP_INSN)
-	bzero ((char *) last_set, nregs * sizeof (rtx));
+	memset ((char *) last_set, 0, nregs * sizeof (rtx));
     }
   *count_ptr = count;
 
@@ -8664,9 +8664,9 @@ load_mems_and_recount_loop_regs_set (loop, insn_count)
 	  VARRAY_GROW (regs->single_usage, nregs);
 	}
       /* Clear the arrays */
-      bzero ((char *) &regs->set_in_loop->data, nregs * sizeof (int));
-      bzero ((char *) &regs->may_not_optimize->data, nregs * sizeof (char));
-      bzero ((char *) &regs->single_usage->data, nregs * sizeof (rtx));
+      memset ((char *) &regs->set_in_loop->data, 0, nregs * sizeof (int));
+      memset ((char *) &regs->may_not_optimize->data, 0, nregs * sizeof (char));
+      memset ((char *) &regs->single_usage->data, 0, nregs * sizeof (rtx));
 
       count_loop_regs_set (loop, regs->may_not_optimize, regs->single_usage,
 			   insn_count, nregs);
diff --git a/gcc/objc/objc-act.c b/gcc/objc/objc-act.c
index 5bb4fcd3694..bea58449373 100644
--- a/gcc/objc/objc-act.c
+++ b/gcc/objc/objc-act.c
@@ -3627,7 +3627,7 @@ error_with_ivar (message, decl, rawdecl)
 
   fprintf (stderr, "%s:%d: ",
 	   DECL_SOURCE_FILE (decl), DECL_SOURCE_LINE (decl));
-  bzero (errbuf, BUFSIZE);
+  memset (errbuf, 0, BUFSIZE);
   fprintf (stderr, "%s `%s'\n", message, gen_declaration (rawdecl, errbuf));
 }
 
@@ -4740,7 +4740,7 @@ build_keyword_selector (selector)
     }
 
   buf = (char *)alloca (len + 1);
-  bzero (buf, len + 1);
+  memset (buf, 0, len + 1);
 
   for (key_chain = selector; key_chain; key_chain = TREE_CHAIN (key_chain))
     {
@@ -4979,7 +4979,7 @@ build_message_expr (mess)
 	       /* Allow any type that matches objc_class_type.  */
 	       && ! comptypes (rtype, objc_class_type))
 	{
-	  bzero (errbuf, BUFSIZE);
+	  memset (errbuf, 0, BUFSIZE);
 	  warning ("invalid receiver type `%s'",
 		   gen_declaration (rtype, errbuf));
 	}
@@ -7079,7 +7079,7 @@ warn_with_method (message, mtype, method)
 
   fprintf (stderr, "%s:%d: warning: ",
 	   DECL_SOURCE_FILE (method), DECL_SOURCE_LINE (method));
-  bzero (errbuf, BUFSIZE);
+  memset (errbuf, 0, BUFSIZE);
   fprintf (stderr, "%s `%c%s'\n",
 	   message, mtype, gen_method_decl (method, errbuf));
 }
@@ -8088,7 +8088,7 @@ dump_interface (fp, chain)
       fprintf (fp, "{\n");
       do
 	{
-	  bzero (buf, 256);
+	  memset (buf, 0, 256);
 	  fprintf (fp, "\t%s;\n", gen_declaration (ivar_decls, buf));
 	  ivar_decls = TREE_CHAIN (ivar_decls);
 	}
@@ -8098,14 +8098,14 @@ dump_interface (fp, chain)
 
   while (nst_methods)
     {
-      bzero (buf, 256);
+      memset (buf, 0, 256);
       fprintf (fp, "- %s;\n", gen_method_decl (nst_methods, buf));
       nst_methods = TREE_CHAIN (nst_methods);
     }
 
   while (cls_methods)
     {
-      bzero (buf, 256);
+      memset (buf, 0, 256);
       fprintf (fp, "+ %s;\n", gen_method_decl (cls_methods, buf));
       cls_methods = TREE_CHAIN (cls_methods);
     }
@@ -8501,7 +8501,7 @@ objc_debug (fp)
 	if (TREE_CODE (loop) == FUNCTION_DECL && DECL_INITIAL (loop))
 	  {
 	    /* We have a function definition: generate prototype.  */
-            bzero (errbuf, BUFSIZE);
+            memset (errbuf, 0, BUFSIZE);
 	    gen_declaration (loop, errbuf);
 	    fprintf (fp, "%s;\n", errbuf);
 	  }
@@ -8521,7 +8521,7 @@ objc_debug (fp)
 	    fprintf (fp, "\n\nnst_method_hash_list[%d]:\n", i);
 	    do
 	      {
-		bzero (buf, 256);
+		memset (buf, 0, 256);
 		fprintf (fp, "-%s;\n", gen_method_decl (hashlist->key, buf));
 		hashlist = hashlist->next;
 	      }
@@ -8536,7 +8536,7 @@ objc_debug (fp)
 	    fprintf (fp, "\n\ncls_method_hash_list[%d]:\n", i);
 	    do
 	      {
-		bzero (buf, 256);
+		memset (buf, 0, 256);
 		fprintf (fp, "-%s;\n", gen_method_decl (hashlist->key, buf));
 		hashlist = hashlist->next;
 	      }
diff --git a/gcc/print-tree.c b/gcc/print-tree.c
index ddc18695be4..d0073fd0c26 100644
--- a/gcc/print-tree.c
+++ b/gcc/print-tree.c
@@ -47,7 +47,7 @@ debug_tree (node)
      tree node;
 {
   table = (struct bucket **) permalloc (HASH_SIZE * sizeof (struct bucket *));
-  bzero ((char *) table, HASH_SIZE * sizeof (struct bucket *));
+  memset ((char *) table, 0, HASH_SIZE * sizeof (struct bucket *));
   print_node (stderr, "", node, 0);
   table = 0;
   fprintf (stderr, "\n");
diff --git a/gcc/regclass.c b/gcc/regclass.c
index 537a34ec5cf..bf6fa0f6b3b 100644
--- a/gcc/regclass.c
+++ b/gcc/regclass.c
@@ -269,7 +269,7 @@ init_reg_sets ()
 
   bcopy (initial_fixed_regs, fixed_regs, sizeof fixed_regs);
   bcopy (initial_call_used_regs, call_used_regs, sizeof call_used_regs);
-  bzero (global_regs, sizeof global_regs);
+  memset (global_regs, 0, sizeof global_regs);
 
   /* Do any additional initialization regsets may need */
   INIT_ONCE_REG_SET ();
@@ -297,7 +297,7 @@ init_reg_sets_1 ()
 
   /* Compute number of hard regs in each class.  */
 
-  bzero ((char *) reg_class_size, sizeof reg_class_size);
+  memset ((char *) reg_class_size, 0, sizeof reg_class_size);
   for (i = 0; i < N_REG_CLASSES; i++)
     for (j = 0; j < FIRST_PSEUDO_REGISTER; j++)
       if (TEST_HARD_REG_BIT (reg_class_contents[i], j))
@@ -1122,10 +1122,10 @@ regclass (f, nregs, dump)
         fprintf (dump, "\n\nPass %i\n\n",pass);
       /* Zero out our accumulation of the cost of each class for each reg.  */
 
-      bzero ((char *) costs, nregs * sizeof (struct costs));
+      memset ((char *) costs, 0, nregs * sizeof (struct costs));
 
 #ifdef FORBIDDEN_INC_DEC_CLASSES
-      bzero (in_inc_dec, nregs);
+      memset (in_inc_dec, 0, nregs);
 #endif
 
       /* Scan the instructions and record each time it would
@@ -1337,7 +1337,7 @@ record_reg_classes (n_alts, n_ops, ops, modes,
 	  if (*p == 0)
 	    {
 	      if (GET_CODE (op) == REG && REGNO (op) >= FIRST_PSEUDO_REGISTER)
-		bzero ((char *) &this_op_costs[i], sizeof this_op_costs[i]);
+		memset ((char *) &this_op_costs[i], 0, sizeof this_op_costs[i]);
 
 	      continue;
 	    }
@@ -2122,7 +2122,7 @@ allocate_reg_info (num_regs, new_p, renumber_p)
 	  if (!reg_data->used_p)	/* page just allocated with calloc */
 	    reg_data->used_p = 1;	/* no need to zero */
 	  else
-	    bzero ((char *) &reg_data->data[local_min],
+	    memset ((char *) &reg_data->data[local_min], 0,
 		   sizeof (reg_info) * (max - min_index - local_min + 1));
 
 	  for (i = min_index+local_min; i <= max; i++)
diff --git a/gcc/reload.c b/gcc/reload.c
index 57ff486f849..65a5e731b41 100644
--- a/gcc/reload.c
+++ b/gcc/reload.c
@@ -647,7 +647,7 @@ get_secondary_mem (x, mode, opnum, type)
 void
 clear_secondary_mem ()
 {
-  bzero ((char *) secondary_memlocs, sizeof secondary_memlocs);
+  memset ((char *) secondary_memlocs, 0, sizeof secondary_memlocs);
 }
 #endif /* SECONDARY_MEMORY_NEEDED */
 
@@ -1558,7 +1558,7 @@ remove_address_replacements (in_rtx)
   char reload_flags[MAX_RELOADS];
   int something_changed = 0;
 
-  bzero (reload_flags, sizeof reload_flags);
+  memset (reload_flags, 0, sizeof reload_flags);
   for (i = 0, j = 0; i < n_replacements; i++)
     {
       if (loc_mentioned_in_p (replacements[i].where, in_rtx))
@@ -2451,7 +2451,7 @@ find_reloads (insn, replace, ind_levels, live_known, reload_reg_p)
   /* The eliminated forms of any secondary memory locations are per-insn, so
      clear them out here.  */
 
-  bzero ((char *) secondary_memlocs_elim, sizeof secondary_memlocs_elim);
+  memset ((char *) secondary_memlocs_elim, 0, sizeof secondary_memlocs_elim);
 #endif
 
   /* Dispose quickly of (set (reg..) (reg..)) if both have hard regs and it
diff --git a/gcc/reload1.c b/gcc/reload1.c
index 9e985e445b2..151529ada8e 100644
--- a/gcc/reload1.c
+++ b/gcc/reload1.c
@@ -631,8 +631,8 @@ reload (first, global)
 #endif
 
   /* We don't have a stack slot for any spill reg yet.  */
-  bzero ((char *) spill_stack_slot, sizeof spill_stack_slot);
-  bzero ((char *) spill_stack_slot_width, sizeof spill_stack_slot_width);
+  memset ((char *) spill_stack_slot, 0, sizeof spill_stack_slot);
+  memset ((char *) spill_stack_slot_width, 0, sizeof spill_stack_slot_width);
 
   /* Initialize the save area information for caller-save, in case some
      are needed.  */
@@ -3281,7 +3281,7 @@ static void
 set_initial_label_offsets ()
 {
   rtx x;
-  bzero ((char *) &offsets_known_at[get_first_label_num ()], num_labels);
+  memset ((char *) &offsets_known_at[get_first_label_num ()], 0, num_labels);
 
   for (x = forced_labels; x; x = XEXP (x, 1))
     if (XEXP (x, 0))
@@ -3555,7 +3555,7 @@ finish_spills (global)
   /* Retry global register allocation if possible.  */
   if (global)
     {
-      bzero ((char *) pseudo_forbidden_regs, max_regno * sizeof (HARD_REG_SET));
+      memset ((char *) pseudo_forbidden_regs, 0, max_regno * sizeof (HARD_REG_SET));
       /* For every insn that needs reloads, set the registers used as spill
 	 regs in pseudo_forbidden_regs for every pseudo live across the
 	 insn.  */
@@ -3726,8 +3726,8 @@ reload_as_needed (live_known)
 #endif
   rtx x;
 
-  bzero ((char *) spill_reg_rtx, sizeof spill_reg_rtx);
-  bzero ((char *) spill_reg_store, sizeof spill_reg_store);
+  memset ((char *) spill_reg_rtx, 0, sizeof spill_reg_rtx);
+  memset ((char *) spill_reg_store, 0, sizeof spill_reg_store);
   reg_last_reload_reg = (rtx *) xcalloc (max_regno, sizeof (rtx));
   reg_has_output_reload = (char *) xmalloc (max_regno);
   CLEAR_HARD_REG_SET (reg_reloaded_valid);
@@ -3788,7 +3788,7 @@ reload_as_needed (live_known)
 	     rtx's for those pseudo regs.  */
 	  else
 	    {
-	      bzero (reg_has_output_reload, max_regno);
+	      memset (reg_has_output_reload, 0, max_regno);
 	      CLEAR_HARD_REG_SET (reg_is_output_reload);
 
 	      find_reloads (insn, 1, spill_indirect_levels, live_known,
@@ -5098,9 +5098,9 @@ choose_reload_regs_init (chain, save_reload_reg_rtx)
   for (i = 0; i < n_reloads; i++)
     rld[i].reg_rtx = save_reload_reg_rtx[i];
 
-  bzero (reload_inherited, MAX_RELOADS);
-  bzero ((char *) reload_inheritance_insn, MAX_RELOADS * sizeof (rtx));
-  bzero ((char *) reload_override_in, MAX_RELOADS * sizeof (rtx));
+  memset (reload_inherited, 0, MAX_RELOADS);
+  memset ((char *) reload_inheritance_insn, 0, MAX_RELOADS * sizeof (rtx));
+  memset ((char *) reload_override_in, 0, MAX_RELOADS * sizeof (rtx));
 
   CLEAR_HARD_REG_SET (reload_reg_used);
   CLEAR_HARD_REG_SET (reload_reg_used_at_all);
@@ -8126,8 +8126,8 @@ reload_cse_simplify_operands (insn)
   alternative_reject = (int *) alloca (recog_data.n_alternatives * sizeof (int));
   alternative_nregs = (int *) alloca (recog_data.n_alternatives * sizeof (int));
   alternative_order = (int *) alloca (recog_data.n_alternatives * sizeof (int));
-  bzero ((char *)alternative_reject, recog_data.n_alternatives * sizeof (int));
-  bzero ((char *)alternative_nregs, recog_data.n_alternatives * sizeof (int));
+  memset ((char *)alternative_reject, 0, recog_data.n_alternatives * sizeof (int));
+  memset ((char *)alternative_nregs, 0, recog_data.n_alternatives * sizeof (int));
 
   /* For each operand, find out which regs are equivalent.  */
   for (i = 0; i < recog_data.n_operands; i++)
diff --git a/gcc/reorg.c b/gcc/reorg.c
index 4005c0ac76b..6d3b26a196f 100644
--- a/gcc/reorg.c
+++ b/gcc/reorg.c
@@ -3589,8 +3589,8 @@ dbr_schedule (first, file)
   end_of_function_label = 0;
 
   /* Initialize the statistics for this function.  */
-  bzero ((char *) num_insns_needing_delays, sizeof num_insns_needing_delays);
-  bzero ((char *) num_filled_delays, sizeof num_filled_delays);
+  memset ((char *) num_insns_needing_delays, 0, sizeof num_insns_needing_delays);
+  memset ((char *) num_filled_delays, 0, sizeof num_filled_delays);
 
   /* Now do the delay slot filling.  Try everything twice in case earlier
      changes make more slots fillable.  */
@@ -3667,8 +3667,8 @@ dbr_schedule (first, file)
 	      fprintf (file, "\n");
 	    }
 	}
-      bzero ((char *) total_delay_slots, sizeof total_delay_slots);
-      bzero ((char *) total_annul_slots, sizeof total_annul_slots);
+      memset ((char *) total_delay_slots, 0, sizeof total_delay_slots);
+      memset ((char *) total_annul_slots, 0, sizeof total_annul_slots);
       for (insn = first; insn; insn = NEXT_INSN (insn))
 	{
 	  if (! INSN_DELETED_P (insn)
diff --git a/gcc/sbitmap.c b/gcc/sbitmap.c
index e3f9a9fd74d..e03cd0442c3 100644
--- a/gcc/sbitmap.c
+++ b/gcc/sbitmap.c
@@ -106,7 +106,7 @@ void
 sbitmap_zero (bmap)
      sbitmap bmap;
 {
-  bzero ((PTR) bmap->elms, bmap->bytes);
+  memset ((PTR) bmap->elms, 0, bmap->bytes);
 }
 
 /* Set all elements in a bitmap to ones.  */
diff --git a/gcc/simplify-rtx.c b/gcc/simplify-rtx.c
index 648dcb4aea5..fcf0831479a 100644
--- a/gcc/simplify-rtx.c
+++ b/gcc/simplify-rtx.c
@@ -1510,7 +1510,7 @@ simplify_plus_minus (code, mode, op0, op1)
   int first = 1, negate = 0, changed;
   int i, j;
 
-  bzero ((char *) ops, sizeof ops);
+  memset ((char *) ops, 0, sizeof ops);
   
   /* Set up the two operands and then expand them until nothing has been
      changed.  If we run out of room in our array, give up; this should
diff --git a/gcc/ssa.c b/gcc/ssa.c
index 2f81e1667df..0bc6dc858f1 100644
--- a/gcc/ssa.c
+++ b/gcc/ssa.c
@@ -1127,8 +1127,8 @@ rename_registers (nregs, idom)
   ssa_rename_from_initialize ();
 
   ssa_rename_to_pseudo = (rtx *) alloca (nregs * sizeof(rtx));
-  bzero ((char *) ssa_rename_to_pseudo, nregs * sizeof(rtx));
-  bzero ((char *) ssa_rename_to_hard, 
+  memset ((char *) ssa_rename_to_pseudo, 0, nregs * sizeof(rtx));
+  memset ((char *) ssa_rename_to_hard, 0, 
 	 FIRST_PSEUDO_REGISTER * NUM_MACHINE_MODES * sizeof (rtx));
 
   rename_block (0, idom);
diff --git a/gcc/stmt.c b/gcc/stmt.c
index b433dd96c83..cf0124b7977 100644
--- a/gcc/stmt.c
+++ b/gcc/stmt.c
@@ -5612,7 +5612,7 @@ expand_end_case (orig_index)
 
 	  ncases = TREE_INT_CST_LOW (range) + 1;
 	  labelvec = (rtx *) alloca (ncases * sizeof (rtx));
-	  bzero ((char *) labelvec, ncases * sizeof (rtx));
+	  memset ((char *) labelvec, 0, ncases * sizeof (rtx));
 
 	  for (n = thiscase->data.case_stmt.case_list; n; n = n->right)
 	    {
diff --git a/gcc/unroll.c b/gcc/unroll.c
index c1a488dc770..a666984045f 100644
--- a/gcc/unroll.c
+++ b/gcc/unroll.c
@@ -1072,10 +1072,10 @@ unroll_loop (loop, insn_count, end_insert_before, strength_reduce_p)
 	      emit_label_after (labels[unroll_number - i],
 				PREV_INSN (loop_start));
 
-	      bzero ((char *) map->insn_map, max_insnno * sizeof (rtx));
-	      bzero ((char *) &VARRAY_CONST_EQUIV (map->const_equiv_varray, 0),
-		     (VARRAY_SIZE (map->const_equiv_varray)
-		      * sizeof (struct const_equiv_data)));
+	      memset ((char *) map->insn_map, 0, max_insnno * sizeof (rtx));
+	      memset ((char *) &VARRAY_CONST_EQUIV (map->const_equiv_varray, 0),
+		      0, (VARRAY_SIZE (map->const_equiv_varray)
+			  * sizeof (struct const_equiv_data)));
 	      map->const_age = 0;
 
 	      for (j = 0; j < max_labelno; j++)
@@ -1219,9 +1219,9 @@ unroll_loop (loop, insn_count, end_insert_before, strength_reduce_p)
 
   for (i = 0; i < unroll_number; i++)
     {
-      bzero ((char *) map->insn_map, max_insnno * sizeof (rtx));
-      bzero ((char *) &VARRAY_CONST_EQUIV (map->const_equiv_varray, 0),
-	     VARRAY_SIZE (map->const_equiv_varray) * sizeof (struct const_equiv_data));
+      memset ((char *) map->insn_map, 0, max_insnno * sizeof (rtx));
+      memset ((char *) &VARRAY_CONST_EQUIV (map->const_equiv_varray, 0), 0,
+	      VARRAY_SIZE (map->const_equiv_varray) * sizeof (struct const_equiv_data));
       map->const_age = 0;
 
       for (j = 0; j < max_labelno; j++)
diff --git a/gcc/varray.c b/gcc/varray.c
index a89fbf8b2e6..7f75bf2f7c3 100644
--- a/gcc/varray.c
+++ b/gcc/varray.c
@@ -64,7 +64,7 @@ varray_grow (va, n)
       va = (varray_type) xrealloc ((char *)va, VARRAY_HDR_SIZE + data_size);
       va->num_elements = n;
       if (n > old_elements)
-	bzero (&va->data.c[old_data_size], data_size - old_data_size);
+	memset (&va->data.c[old_data_size], 0, data_size - old_data_size);
     }
 
   return va;