OpenE2K
/
gcc
2
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

alias.c [...] (init_alias_analysis, [...]): Use memset () instead of bzero (). 

* 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 ().

ch:
	* actions.c (check_missing_cases), typeck.c (build_chill_slice,
	build_chill_cast): Use memset () instead of bzero ().

cp:
	* 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 ().

java:
	* 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 ().

From-SVN: r37303
This commit is contained in:
Joseph Myers 2000-11-07 22:50:06 +00:00 committed by Joseph Myers
parent 0b13d6c243
commit 961192e1dd
45 changed files with 167 additions and 121 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

28
gcc/ChangeLog
View File

@ -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.

6
gcc/alias.c
View File

@ -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.

10
gcc/calls.c
View File

@ -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;

5
gcc/ch/ChangeLog
View File

@ -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.

2
gcc/ch/actions.c
View File

@ -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);

4
gcc/ch/typeck.c
View File

@ -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");

18
gcc/combine.c
View File

@ -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. */

7
gcc/cp/ChangeLog
View File

@ -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.

4
gcc/cp/class.c
View File

@ -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;

2
gcc/cp/decl.c
View File

@ -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;

2
gcc/cp/error.c
View File

@ -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);

8
gcc/cp/pt.c
View File

@ -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++)
{

2
gcc/cp/search.c
View File

@ -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;

2
gcc/cse.c
View File

@ -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)
{

2
gcc/dbxout.c
View File

@ -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;
}

4
gcc/diagnostic.c
View File

@ -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;

4
gcc/dwarf2out.c
View File

@ -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;
}

2
gcc/emit-rtl.c
View File

@ -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);

8
gcc/fold-const.c
View File

@ -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);

2
gcc/function.c
View File

@ -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;
}

16
gcc/gcse.c
View File

@ -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);

2
gcc/genattrtab.c
View File

@ -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. */

6
gcc/global.c
View File

@ -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.

10
gcc/haifa-sched.c
View File

@ -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;

4
gcc/integrate.c
View File

@ -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

6
gcc/java/ChangeLog
View File

@ -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.

2
gcc/java/expr.c
View File

@ -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;)

2
gcc/java/jcf-io.c
View File

@ -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);

2
gcc/java/jcf-parse.c
View File

@ -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

4
gcc/java/lex.c
View File

@ -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

2
gcc/jump.c
View File

@ -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,

2
gcc/local-alloc.c
View File

@ -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);

10
gcc/loop.c
View File

@ -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);

20
gcc/objc/objc-act.c
View File

@ -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;
}

2
gcc/print-tree.c
View File

@ -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");

12
gcc/regclass.c
View File

@ -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++)

6
gcc/reload.c
View File

@ -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

24
gcc/reload1.c
View File

@ -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++)

8
gcc/reorg.c
View File

@ -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)

2
gcc/sbitmap.c
View File

@ -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. */

2
gcc/simplify-rtx.c
View File

@ -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

4
gcc/ssa.c
View File

@ -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);

2
gcc/stmt.c
View File

@ -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)
{

14
gcc/unroll.c
View File

@ -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++)

2
gcc/varray.c
View File

@ -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;