diff options
45 files changed, 167 insertions, 121 deletions
diff --git a/gcc/ChangeLog b/gcc/ChangeLog index 06d9768..4c2a7f8 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 28016d3..e9e30ee 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 09f08e4..ec0ad09 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 fb5d21b..c8d5766 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 32bb181..09c8a5a 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 7c4f554..ef4a2e3 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 6373895..18c5322 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 62edaf5..d11ff26 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 8ddc474..ff6f34c 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 f4d170a..3356720 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 9fbd8a7..9717ce0 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 9465a1d..7098d7d 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 67f16fb..a7fdc86 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; @@ -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 7da5ad8..f25eb34 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 5d6d1c8..c2fe71a 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 77de3a9..507c9a7 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 3929e88..c73b346 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 58d84ef..da27f47 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 c7ff587..f86521a 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; } @@ -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 (®_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 0796a1b..d3f77b0 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 7f426df..54d18c8 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 e85cd20..2ab6377 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 8bf949b..34aa4bf 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 46fe17d..f4eff53 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 286fa6a..2d59229 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 db19208..03ea7d7 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 30fc4a4..090120a 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 be1fcf8..1b8898c 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 @@ -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 2d7cac8..2315338 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); @@ -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 *) ®s->set_in_loop->data, nregs * sizeof (int)); - bzero ((char *) ®s->may_not_optimize->data, nregs * sizeof (char)); - bzero ((char *) ®s->single_usage->data, nregs * sizeof (rtx)); + memset ((char *) ®s->set_in_loop->data, 0, nregs * sizeof (int)); + memset ((char *) ®s->may_not_optimize->data, 0, nregs * sizeof (char)); + memset ((char *) ®s->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 5bb4fcd..bea5844 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 ddc18695..d0073fd 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 537a34e..bf6fa0f 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 *) ®_data->data[local_min], + memset ((char *) ®_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 57ff486..65a5e73 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 9e985e4..151529a 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 4005c0a..6d3b26a 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 e3f9a9f..e03cd04 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 648dcb4..fcf0831 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 @@ -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); @@ -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 c1a488d..a666984 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 a89fbf8..7f75bf2 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; |