Leahnaya/agbcc
1
0
Fork 0
mirror of https://github.com/pret/agbcc.git synced 2026-04-25 15:35:13 -05:00
Code Issues Actions Packages Projects Releases Wiki Activity

remove use of strings.h

Browse Source
This commit is contained in:
YamaArashi 2016-02-13 02:16:07 -08:00
parent 56d3f75d13
commit 87926b4bcc
60 changed files with 432 additions and 1650 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
gcc/alias.c
View File

@ -1348,9 +1348,9 @@ init_alias_analysis ()
- FIRST_PSEUDO_REGISTER;
reg_known_equiv_p =
oballoc (maxreg - FIRST_PSEUDO_REGISTER) - FIRST_PSEUDO_REGISTER;
bzero ((char *) (reg_known_value + FIRST_PSEUDO_REGISTER),
zero_memory ((char *) (reg_known_value + FIRST_PSEUDO_REGISTER),
(maxreg-FIRST_PSEUDO_REGISTER) * sizeof (rtx));
bzero (reg_known_equiv_p + FIRST_PSEUDO_REGISTER,
zero_memory (reg_known_equiv_p + FIRST_PSEUDO_REGISTER,
(maxreg - FIRST_PSEUDO_REGISTER) * sizeof (char));
/* Overallocate reg_base_value to allow some growth during loop
@ -1360,12 +1360,12 @@ init_alias_analysis ()
reg_base_value = (rtx *)oballoc (reg_base_value_size * sizeof (rtx));
new_reg_base_value = (rtx *)alloca (reg_base_value_size * sizeof (rtx));
reg_seen = (char *)alloca (reg_base_value_size);
bzero ((char *) reg_base_value, reg_base_value_size * sizeof (rtx));
zero_memory ((char *) reg_base_value, reg_base_value_size * sizeof (rtx));
if (! reload_completed && flag_unroll_loops)
{
alias_invariant = (rtx *)xrealloc (alias_invariant,
reg_base_value_size * sizeof (rtx));
bzero ((char *)alias_invariant, reg_base_value_size * sizeof (rtx));
zero_memory ((char *)alias_invariant, reg_base_value_size * sizeof (rtx));
}
@ -1403,10 +1403,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));
zero_memory ((char *) new_reg_base_value, reg_base_value_size * sizeof (rtx));
/* Wipe the reg_seen array clean. */
bzero ((char *) reg_seen, reg_base_value_size);
zero_memory ((char *) reg_seen, reg_base_value_size);
/* Mark all hard registers which may contain an address.
The stack, frame and argument pointers may contain an address.

40
gcc/c-common.c
View File

@ -1462,12 +1462,12 @@ check_format_info (info, params)
}
else if (info->format_type == strftime_format_type)
{
while (*format_chars != 0 && index ("_-0^#", *format_chars) != 0)
while (*format_chars != 0 && strchr ("_-0^#", *format_chars) != 0)
{
if (pedantic)
warning ("ANSI C does not support the strftime `%c' flag",
*format_chars);
if (index (flag_chars, *format_chars) != 0)
if (strchr (flag_chars, *format_chars) != 0)
{
warning ("repeated `%c' flag in format",
*format_chars);
@ -1530,9 +1530,9 @@ check_format_info (info, params)
}
}
while (*format_chars != 0 && index (" +#0-", *format_chars) != 0)
while (*format_chars != 0 && strchr (" +#0-", *format_chars) != 0)
{
if (index (flag_chars, *format_chars) != 0)
if (strchr (flag_chars, *format_chars) != 0)
warning ("repeated `%c' flag in format", *format_chars++);
else
{
@ -1543,13 +1543,13 @@ check_format_info (info, params)
}
/* "If the space and + flags both appear,
the space flag will be ignored." */
if (index (flag_chars, ' ') != 0
&& index (flag_chars, '+') != 0)
if (strchr (flag_chars, ' ') != 0
&& strchr (flag_chars, '+') != 0)
warning ("use of both ` ' and `+' flags in format");
/* "If the 0 and - flags both appear,
the 0 flag will be ignored." */
if (index (flag_chars, '0') != 0
&& index (flag_chars, '-') != 0)
if (strchr (flag_chars, '0') != 0
&& strchr (flag_chars, '-') != 0)
warning ("use of both `0' and `-' flags in format");
if (*format_chars == '*')
{
@ -1702,7 +1702,7 @@ check_format_info (info, params)
abort ();
}
while (fci->format_chars != 0
&& index (fci->format_chars, format_char) == 0)
&& strchr (fci->format_chars, format_char) == 0)
++fci;
if (fci->format_chars == 0)
{
@ -1716,22 +1716,22 @@ check_format_info (info, params)
}
if (pedantic)
{
if (index (fci->flag_chars, 'G') != 0)
if (strchr (fci->flag_chars, 'G') != 0)
warning ("ANSI C does not support `%%%c'", format_char);
if (index (fci->flag_chars, 'o') != 0
&& index (flag_chars, 'O') != 0)
if (strchr (fci->flag_chars, 'o') != 0
&& strchr (flag_chars, 'O') != 0)
warning ("ANSI C does not support `%%O%c'", format_char);
}
if (wide && index (fci->flag_chars, 'w') == 0)
if (wide && strchr (fci->flag_chars, 'w') == 0)
warning ("width used with `%c' format", format_char);
if (index (fci->flag_chars, '2') != 0)
if (strchr (fci->flag_chars, '2') != 0)
warning ("`%%%c' yields only last 2 digits of year", format_char);
else if (index (fci->flag_chars, '3') != 0)
else if (strchr (fci->flag_chars, '3') != 0)
warning ("`%%%c' yields only last 2 digits of year in some locales",
format_char);
if (precise && index (fci->flag_chars, 'p') == 0)
if (precise && strchr (fci->flag_chars, 'p') == 0)
warning ("precision used with `%c' format", format_char);
if (aflag && index (fci->flag_chars, 'a') == 0)
if (aflag && strchr (fci->flag_chars, 'a') == 0)
{
warning ("`a' flag used with `%c' format", format_char);
/* To simplify the following code. */
@ -1757,19 +1757,19 @@ check_format_info (info, params)
}
if (suppressed)
{
if (index (fci->flag_chars, '*') == 0)
if (strchr (fci->flag_chars, '*') == 0)
warning ("suppression of `%c' conversion in format", format_char);
continue;
}
for (i = 0; flag_chars[i] != 0; ++i)
{
if (index (fci->flag_chars, flag_chars[i]) == 0)
if (strchr (fci->flag_chars, flag_chars[i]) == 0)
warning ("flag `%c' used with type `%c'",
flag_chars[i], format_char);
}
if (info->format_type == strftime_format_type)
continue;
if (precise && index (flag_chars, '0') != 0
if (precise && strchr (flag_chars, '0') != 0
&& (format_char == 'd' || format_char == 'i'
|| format_char == 'o' || format_char == 'u'
|| format_char == 'x' || format_char == 'X'))

2
gcc/c-decl.c
View File

@ -2096,7 +2096,7 @@ duplicate_decls (newdecl, olddecl, different_binding_level)
{
register unsigned olddecl_uid = DECL_UID (olddecl);
bcopy ((char *) newdecl + sizeof (struct tree_common),
copy_memory ((char *) newdecl + sizeof (struct tree_common),
(char *) olddecl + sizeof (struct tree_common),
sizeof (struct tree_decl) - sizeof (struct tree_common));
DECL_UID (olddecl) = olddecl_uid;

4
gcc/c-lex.c
View File

@ -1432,7 +1432,7 @@ yylex ()
and not the suffixes; once we add `f' or `i',
REAL_VALUE_ATOF may not work any more. */
char *copy = (char *) alloca (p - token_buffer + 1);
bcopy (token_buffer, copy, p - token_buffer + 1);
copy_memory (token_buffer, copy, p - token_buffer + 1);
set_float_handler (handler);
@ -2014,7 +2014,7 @@ yylex ()
{
if (p + WCHAR_BYTES > token_buffer + maxtoken)
p = extend_token_buffer (p);
bzero (p, WCHAR_BYTES);
zero_memory (p, WCHAR_BYTES);
p += WCHAR_BYTES;
}
else

20
gcc/calls.c
View File

@ -1271,7 +1271,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));
zero_memory ((char *) args, num_actuals * sizeof (struct arg_data));
args_size.constant = 0;
args_size.var = 0;
@ -1747,11 +1747,11 @@ expand_call (exp, target, ignore)
stack_usage_map = (char *) alloca (highest_outgoing_arg_in_use);
if (initial_highest_arg_in_use)
bcopy (initial_stack_usage_map, stack_usage_map,
copy_memory (initial_stack_usage_map, stack_usage_map,
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],
zero_memory (&stack_usage_map[initial_highest_arg_in_use],
highest_outgoing_arg_in_use - initial_highest_arg_in_use);
needed = 0;
@ -1819,7 +1819,7 @@ expand_call (exp, target, ignore)
stack_arg_under_construction = 0;
/* 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);
zero_memory (stack_usage_map, highest_outgoing_arg_in_use);
highest_outgoing_arg_in_use = 0;
}
allocate_dynamic_stack_space (push_size, NULL_RTX, BITS_PER_UNIT);
@ -2416,7 +2416,7 @@ emit_library_call VPROTO((rtx orgfun, int no_queue, enum machine_mode outmode,
library functions shouldn't have many args. */
argvec = (struct arg *) alloca (nargs * sizeof (struct arg));
bzero ((char *) argvec, nargs * sizeof (struct arg));
zero_memory ((char *) argvec, nargs * sizeof (struct arg));
INIT_CUMULATIVE_ARGS (args_so_far, NULL_TREE, fun, 0);
@ -2553,11 +2553,11 @@ emit_library_call VPROTO((rtx orgfun, int no_queue, enum machine_mode outmode,
stack_usage_map = (char *) alloca (highest_outgoing_arg_in_use);
if (initial_highest_arg_in_use)
bcopy (initial_stack_usage_map, stack_usage_map,
copy_memory (initial_stack_usage_map, stack_usage_map,
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],
zero_memory (&stack_usage_map[initial_highest_arg_in_use],
highest_outgoing_arg_in_use - initial_highest_arg_in_use);
needed = 0;
@ -2942,7 +2942,7 @@ emit_library_call_value VPROTO((rtx orgfun, rtx value, int no_queue,
library functions shouldn't have many args. */
argvec = (struct arg *) alloca ((nargs + 1) * sizeof (struct arg));
bzero ((char *) argvec, (nargs + 1) * sizeof (struct arg));
zero_memory ((char *) argvec, (nargs + 1) * sizeof (struct arg));
INIT_CUMULATIVE_ARGS (args_so_far, NULL_TREE, fun, 0);
@ -3116,11 +3116,11 @@ emit_library_call_value VPROTO((rtx orgfun, rtx value, int no_queue,
stack_usage_map = (char *) alloca (highest_outgoing_arg_in_use);
if (initial_highest_arg_in_use)
bcopy (initial_stack_usage_map, stack_usage_map,
copy_memory (initial_stack_usage_map, stack_usage_map,
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],
zero_memory (&stack_usage_map[initial_highest_arg_in_use],
highest_outgoing_arg_in_use - initial_highest_arg_in_use);
needed = 0;

24
gcc/combine.c
View File

@ -479,8 +479,8 @@ combine_instructions (f, nregs)
= (unsigned HOST_WIDE_INT *) alloca (nregs * sizeof (HOST_WIDE_INT));
reg_sign_bit_copies = (char *) alloca (nregs * sizeof (char));
bzero ((char *) reg_nonzero_bits, nregs * sizeof (HOST_WIDE_INT));
bzero (reg_sign_bit_copies, nregs * sizeof (char));
zero_memory ((char *) reg_nonzero_bits, nregs * sizeof (HOST_WIDE_INT));
zero_memory (reg_sign_bit_copies, nregs * sizeof (char));
reg_last_death = (rtx *) alloca (nregs * sizeof (rtx));
reg_last_set = (rtx *) alloca (nregs * sizeof (rtx));
@ -686,15 +686,15 @@ init_reg_last_arrays ()
{
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));
zero_memory ((char *) reg_last_death, nregs * sizeof (rtx));
zero_memory ((char *) reg_last_set, nregs * sizeof (rtx));
zero_memory ((char *) reg_last_set_value, nregs * sizeof (rtx));
zero_memory ((char *) reg_last_set_table_tick, nregs * sizeof (int));
zero_memory ((char *) reg_last_set_label, nregs * sizeof (int));
zero_memory (reg_last_set_invalid, nregs * sizeof (char));
zero_memory ((char *) reg_last_set_mode, nregs * sizeof (enum machine_mode));
zero_memory ((char *) reg_last_set_nonzero_bits, nregs * sizeof (HOST_WIDE_INT));
zero_memory (reg_last_set_sign_bit_copies, nregs * sizeof (char));
}
/* Set up any promoted values for incoming argument registers. */
@ -1902,7 +1902,7 @@ try_combine (i3, i2, i1)
rtvec old = XVEC (newpat, 0);
total_sets = XVECLEN (newpat, 0) + added_sets_1 + added_sets_2;
newpat = gen_rtx_PARALLEL (VOIDmode, rtvec_alloc (total_sets));
bcopy ((char *) &old->elem[0], (char *) XVEC (newpat, 0)->elem,
copy_memory ((char *) &old->elem[0], (char *) XVEC (newpat, 0)->elem,
sizeof (old->elem[0]) * old->num_elem);
}
else

2
gcc/cppexp.c
View File

@ -994,7 +994,7 @@ cpp_parse_expr (pfile)
else
{
new_stack = (struct operation *) xmalloc (new_size);
bcopy ((char *) stack, (char *) new_stack, old_size);
copy_memory ((char *) stack, (char *) new_stack, old_size);
}
stack = new_stack;
top = (struct operation *) ((char *) new_stack + old_size);

12
gcc/cppfiles.c
View File

@ -431,7 +431,7 @@ find_include_file (pfile, fname, search_start, ihash, before)
for (l = search_start; l; l = l->next)
{
bcopy (l->name, name, l->nlen);
copy_memory (l->name, name, l->nlen);
name[l->nlen] = '/';
strcpy (&name[l->nlen+1], fname);
simplify_pathname (name);
@ -632,7 +632,7 @@ remap_filename (pfile, name, loc)
looking in. Thus #include <sys/types.h> will look up sys/types.h
in /usr/include/header.gcc and look up types.h in
/usr/include/sys/header.gcc. */
p = rindex (name, '/');
p = strrchr (name, '/');
if (!p)
p = name;
if (loc && loc->name
@ -649,7 +649,7 @@ remap_filename (pfile, name, loc)
else
{
char * newdir = (char *) alloca (p - name + 1);
bcopy (name, newdir, p - name);
copy_memory (name, newdir, p - name);
newdir[p - name] = '\0';
dir = newdir;
from = p + 1;
@ -796,7 +796,7 @@ actual_directory (pfile, fname)
struct file_name_list *x;
dir = xstrdup (fname);
last_slash = rindex (dir, '/');
last_slash = strrchr (dir, '/');
if (last_slash)
{
if (last_slash == dir)
@ -917,13 +917,13 @@ deps_output (pfile, string, spacer)
if (cr)
{
bcopy (" \\\n ", &pfile->deps_buffer[pfile->deps_size], 5);
copy_memory (" \\\n ", &pfile->deps_buffer[pfile->deps_size], 5);
pfile->deps_size += 5;
}
if (spacer == ' ' && pfile->deps_column > 0)
pfile->deps_buffer[pfile->deps_size++] = ' ';
bcopy (string, &pfile->deps_buffer[pfile->deps_size], size);
copy_memory (string, &pfile->deps_buffer[pfile->deps_size], size);
pfile->deps_size += size;
pfile->deps_column += size;
if (spacer == ':')

2
gcc/cpphash.c
View File

@ -182,7 +182,7 @@ install (name, len, type, ivalue, value, hash)
else
hp->value.cpval = value;
hp->name = ((U_CHAR *) hp) + sizeof (HASHNODE);
bcopy (name, hp->name, len);
copy_memory (name, hp->name, len);
hp->name[len] = 0;
return hp;
}

56
gcc/cpplib.c
View File

@ -548,7 +548,7 @@ path_include (pfile, path)
} else {
/* Otherwise use the directory that is named. */
name = (char *) xmalloc (q - p + 1);
bcopy (p, name, q - p);
copy_memory (p, name, q - p);
name[q - p] = 0;
}
@ -568,7 +568,7 @@ void
cpp_options_init (opts)
cpp_options *opts;
{
bzero ((char *) opts, sizeof *opts);
zero_memory ((char *) opts, sizeof *opts);
opts->in_fname = NULL;
opts->out_fname = NULL;
@ -1357,7 +1357,7 @@ create_definition (buf, limit, pfile, predefinition)
struct arglist *temp;
int i = 0;
for (temp = arg_ptrs; temp; temp = temp->next) {
bcopy (temp->name, &defn->args.argnames[i], temp->length);
copy_memory (temp->name, &defn->args.argnames[i], temp->length);
i += temp->length;
if (temp->next != 0) {
defn->args.argnames[i++] = ',';
@ -1434,7 +1434,7 @@ check_macro_name (pfile, symname, usage)
else if (!is_idstart[*symname]) {
U_CHAR *msg; /* what pain... */
msg = (U_CHAR *) alloca (sym_length + 1);
bcopy (symname, msg, sym_length);
copy_memory (symname, msg, sym_length);
msg[sym_length] = 0;
cpp_error (pfile, "invalid %s name `%s'", usage, msg);
} else {
@ -1546,7 +1546,7 @@ do_define (pfile, keyword)
buf = pfile->token_buffer + here;
end = CPP_PWRITTEN (pfile);
macro = alloca (end - buf + 1);
bcopy (buf, macro, end - buf + 1);
copy_memory (buf, macro, end - buf + 1);
end = macro + (end - buf);
CPP_SET_WRITTEN (pfile, here);
@ -1587,7 +1587,7 @@ do_define (pfile, keyword)
msg = (U_CHAR *) alloca (mdef.symlen + 22);
*msg = '`';
bcopy (mdef.symnam, msg + 1, mdef.symlen);
copy_memory (mdef.symnam, msg + 1, mdef.symlen);
strcpy ((char *) (msg + mdef.symlen + 1), "' redefined");
cpp_pedwarn (pfile, msg);
if (hp->type == T_MACRO)
@ -1656,7 +1656,7 @@ cpp_push_buffer (pfile, buffer, length)
return NULL;
}
buf--;
bzero ((char *) buf, sizeof (cpp_buffer));
zero_memory ((char *) buf, sizeof (cpp_buffer));
CPP_BUFFER (pfile) = buf;
buf->if_stack = pfile->if_stack;
buf->cleanup = null_cleanup;
@ -2161,7 +2161,7 @@ special_symbol (hp, pfile)
sprintf (buf, "%d", hp->value.ival);
#ifdef STDC_0_IN_SYSTEM_HEADERS
if (ip->system_header_p
&& hp->length == 8 && bcmp (hp->name, "__STDC__", 8) == 0
&& hp->length == 8 && memcmp (hp->name, "__STDC__", 8) == 0
&& ! cpp_lookup (pfile, (U_CHAR *) "__STRICT_ANSI__", -1, -1))
strcpy (buf, "0");
#endif
@ -2684,7 +2684,7 @@ macroexpand (pfile, hp)
if (ap->stringify != 0)
{
bcopy (ARG_BASE + arg->stringified,
copy_memory (ARG_BASE + arg->stringified,
xbuf + totlen, arg->stringified_length);
totlen += arg->stringified_length;
}
@ -2737,7 +2737,7 @@ macroexpand (pfile, hp)
if (p1[0] == '@' && p1[1] == '-')
p1 += 2;
bcopy (p1, xbuf + totlen, l1 - p1);
copy_memory (p1, xbuf + totlen, l1 - p1);
totlen += l1 - p1;
}
else
@ -2751,7 +2751,7 @@ macroexpand (pfile, hp)
xbuf[totlen++] = ' ';
}
bcopy (expanded, xbuf + totlen, arg->expand_length);
copy_memory (expanded, xbuf + totlen, arg->expand_length);
totlen += arg->expand_length;
if (!ap->raw_after && totlen > 0 && offset < defn->length
@ -3264,7 +3264,7 @@ do_line (pfile, keyword)
hp->length = fname_length;
ip->nominal_fname = hp->value.cpval = ((char *) hp) + sizeof (HASHNODE);
bcopy (fname, hp->value.cpval, fname_length);
copy_memory (fname, hp->value.cpval, fname_length);
}
}
else if (token != CPP_VSPACE && token != CPP_EOF) {
@ -3313,7 +3313,7 @@ do_undef (pfile, keyword)
/* Copy out the token so we can pop the token buffer. */
name = alloca (limit - buf + 1);
bcopy(buf, name, limit - buf);
copy_memory(buf, name, limit - buf);
name[limit - buf] = '\0';
token = get_directive_token (pfile);
@ -3474,10 +3474,10 @@ do_pragma (pfile, keyword)
return 0;
fname = p + 1;
p = (U_CHAR *) index (fname, '\"');
p = (U_CHAR *) strchr (fname, '\"');
fcopy = alloca (p - fname + 1);
bcopy (fname, fcopy, p - fname);
copy_memory (fname, fcopy, p - fname);
fcopy[p-fname] = '\0';
ptr = include_hash (pfile, fcopy, 0);
@ -3640,7 +3640,7 @@ do_xifdef (pfile, keyword)
if (start_of_file && !skip)
{
control_macro = (U_CHAR *) xmalloc (ident_length + 1);
bcopy (ident, control_macro, ident_length + 1);
copy_memory (ident, control_macro, ident_length + 1);
}
}
else
@ -4103,14 +4103,14 @@ cpp_get_token (pfile)
if (lintcmd != NULL) {
/* I believe it is always safe to emit this newline: */
obp[-1] = '\n';
bcopy ("#pragma lint ", (char *) obp, 13);
copy_memory ("#pragma lint ", (char *) obp, 13);
obp += 13;
bcopy (lintcmd, (char *) obp, cmdlen);
copy_memory (lintcmd, (char *) obp, cmdlen);
obp += cmdlen;
if (arglen != 0) {
*(obp++) = ' ';
bcopy (argbp, (char *) obp, arglen);
copy_memory (argbp, (char *) obp, arglen);
obp += arglen;
}
@ -4571,7 +4571,7 @@ cpp_get_token (pfile)
xbuf_len = CPP_WRITTEN (pfile) - before_name_written;
xbuf = (U_CHAR *) xmalloc (xbuf_len + 1);
CPP_SET_WRITTEN (pfile, before_name_written);
bcopy (CPP_PWRITTEN (pfile), xbuf, xbuf_len + 1);
copy_memory (CPP_PWRITTEN (pfile), xbuf, xbuf_len + 1);
push_macro_expansion (pfile, xbuf, xbuf_len, hp);
}
else
@ -4906,7 +4906,7 @@ cpp_start_read (pfile, fname)
endp++;
}
/* Put the usual defaults back in at the end. */
bcopy ((char *) include_defaults_array,
copy_memory ((char *) include_defaults_array,
(char *) &include_defaults[num_dirs],
sizeof (include_defaults_array));
}
@ -5017,7 +5017,7 @@ cpp_start_read (pfile, fname)
{
opts->deps_target = s + 1;
output_file = (char *) xmalloc (s - spec + 1);
bcopy (spec, output_file, s - spec);
copy_memory (spec, output_file, s - spec);
output_file[s - spec] = 0;
}
else
@ -5054,9 +5054,9 @@ cpp_start_read (pfile, fname)
};
/* Discard all directory prefixes from filename. */
if ((q = rindex (opts->in_fname, '/')) != NULL
if ((q = strrchr (opts->in_fname, '/')) != NULL
#ifdef DIR_SEPARATOR
&& (q = rindex (opts->in_fname, DIR_SEPARATOR)) != NULL
&& (q = strrchr (opts->in_fname, DIR_SEPARATOR)) != NULL
#endif
)
++q;
@ -5071,7 +5071,7 @@ cpp_start_read (pfile, fname)
len = strlen (p);
q = p + len;
/* Point to the filename suffix. */
r = rindex (p, '.');
r = strrchr (p, '.');
/* Compare against the known suffixes. */
x = 0;
while (known_suffixes[x] != 0)
@ -5216,7 +5216,7 @@ void
cpp_reader_init (pfile)
cpp_reader *pfile;
{
bzero ((char *) pfile, sizeof (cpp_reader));
zero_memory ((char *) pfile, sizeof (cpp_reader));
pfile->get_token = cpp_get_token;
pfile->token_buffer_size = 200;
@ -6042,7 +6042,7 @@ do_assert (pfile, keyword)
}
thislen = strlen (sym);
baselen = index (sym, '(') - sym;
baselen = strchr (sym, '(') - sym;
this = cpp_lookup (pfile, sym, thislen, -1);
if (this)
{
@ -6118,7 +6118,7 @@ do_unassert (pfile, keyword)
}
else
{
baselen = index (sym, '(') - sym;
baselen = strchr (sym, '(') - sym;
base = cpp_lookup (pfile, sym, baselen, -1);
if (! base) goto error;
this = cpp_lookup (pfile, sym, thislen, -1);

16
gcc/cse.c
View File

@ -797,11 +797,11 @@ new_basic_block ()
next_qty = max_reg;
bzero ((char *) reg_tick, max_reg * sizeof (int));
zero_memory ((char *) reg_tick, max_reg * sizeof (int));
bcopy ((char *) all_minus_one, (char *) reg_in_table,
copy_memory ((char *) all_minus_one, (char *) reg_in_table,
max_reg * sizeof (int));
bcopy ((char *) consec_ints, (char *) reg_qty, max_reg * sizeof (int));
copy_memory ((char *) consec_ints, (char *) reg_qty, max_reg * sizeof (int));
CLEAR_HARD_REG_SET (hard_regs_in_table);
/* The per-quantity values used to be initialized here, but it is
@ -817,7 +817,7 @@ new_basic_block ()
}
}
bzero ((char *) table, sizeof table);
zero_memory ((char *) table, sizeof table);
prev_insn = 0;
@ -4371,7 +4371,7 @@ simplify_plus_minus (code, mode, op0, op1)
int first = 1, negate = 0, changed;
int i, j;
bzero ((char *) ops, sizeof ops);
zero_memory ((char *) ops, 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
@ -8584,7 +8584,7 @@ cse_main (f, nregs, after_loop, file)
/* Discard all the free elements of the previous function
since they are allocated in the temporarily obstack. */
bzero ((char *) table, sizeof table);
zero_memory ((char *) table, sizeof table);
free_element_chain = 0;
n_elements_made = 0;
@ -8592,7 +8592,7 @@ cse_main (f, nregs, after_loop, file)
max_uid = get_max_uid ();
uid_cuid = (int *) alloca ((max_uid + 1) * sizeof (int));
bzero ((char *) uid_cuid, (max_uid + 1) * sizeof (int));
zero_memory ((char *) uid_cuid, (max_uid + 1) * sizeof (int));
/* Compute the mapping from uids to cuids.
CUIDs are numbers assigned to insns, like uids,
@ -9056,7 +9056,7 @@ delete_trivially_dead_insns (insns, nreg)
int in_libcall = 0, dead_libcall = 0;
/* First count the number of times each register is used. */
bzero ((char *) counts, sizeof (int) * nreg);
zero_memory ((char *) counts, sizeof (int) * nreg);
for (insn = next_real_insn (insns); insn; insn = next_real_insn (insn))
count_reg_usage (insn, counts, NULL_RTX, 1);

16
gcc/dwarf2out.c
View File

@ -1955,7 +1955,7 @@ dwarf2out_frame_init ()
/* Allocate the initial hunk of the fde_table. */
fde_table
= (dw_fde_ref) xmalloc (FDE_TABLE_INCREMENT * sizeof (dw_fde_node));
bzero ((char *) fde_table, FDE_TABLE_INCREMENT * sizeof (dw_fde_node));
zero_memory ((char *) fde_table, FDE_TABLE_INCREMENT * sizeof (dw_fde_node));
fde_table_allocated = FDE_TABLE_INCREMENT;
fde_table_in_use = 0;
@ -4188,7 +4188,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],
zero_memory ((char *) &decl_die_table[decl_die_table_allocated],
(num_allocated - decl_die_table_allocated) * sizeof (dw_die_ref));
decl_die_table_allocated = num_allocated;
}
@ -4460,7 +4460,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],
zero_memory ((char *) &abbrev_die_table[abbrev_die_table_allocated],
(n_alloc - abbrev_die_table_allocated) * sizeof (dw_die_ref));
abbrev_die_table_allocated = n_alloc;
}
@ -9773,7 +9773,7 @@ dwarf2out_init (asm_out_file, main_input_filename)
/* Allocate the initial hunk of the file_table. */
file_table = (char **) xmalloc (FILE_TABLE_INCREMENT * sizeof (char *));
bzero ((char *) file_table, FILE_TABLE_INCREMENT * sizeof (char *));
zero_memory ((char *) file_table, FILE_TABLE_INCREMENT * sizeof (char *));
file_table_allocated = FILE_TABLE_INCREMENT;
/* Skip the first entry - file numbers begin at 1. */
@ -9782,7 +9782,7 @@ dwarf2out_init (asm_out_file, main_input_filename)
/* Allocate the initial hunk of the decl_die_table. */
decl_die_table
= (dw_die_ref *) xmalloc (DECL_DIE_TABLE_INCREMENT * sizeof (dw_die_ref));
bzero ((char *) decl_die_table,
zero_memory ((char *) decl_die_table,
DECL_DIE_TABLE_INCREMENT * sizeof (dw_die_ref));
decl_die_table_allocated = DECL_DIE_TABLE_INCREMENT;
decl_die_table_in_use = 0;
@ -9791,7 +9791,7 @@ dwarf2out_init (asm_out_file, main_input_filename)
decl_scope_table
= (decl_scope_node *) xmalloc (DECL_SCOPE_TABLE_INCREMENT
* sizeof (decl_scope_node));
bzero ((char *) decl_scope_table,
zero_memory ((char *) decl_scope_table,
DECL_SCOPE_TABLE_INCREMENT * sizeof (decl_scope_node));
decl_scope_table_allocated = DECL_SCOPE_TABLE_INCREMENT;
decl_scope_depth = 0;
@ -9800,7 +9800,7 @@ dwarf2out_init (asm_out_file, main_input_filename)
abbrev_die_table
= (dw_die_ref *) xmalloc (ABBREV_DIE_TABLE_INCREMENT
* sizeof (dw_die_ref));
bzero ((char *) abbrev_die_table,
zero_memory ((char *) abbrev_die_table,
ABBREV_DIE_TABLE_INCREMENT * sizeof (dw_die_ref));
abbrev_die_table_allocated = ABBREV_DIE_TABLE_INCREMENT;
/* Zero-th entry is allocated, but unused */
@ -9810,7 +9810,7 @@ dwarf2out_init (asm_out_file, main_input_filename)
line_info_table
= (dw_line_info_ref) xmalloc (LINE_INFO_TABLE_INCREMENT
* sizeof (dw_line_info_entry));
bzero ((char *) line_info_table,
zero_memory ((char *) line_info_table,
LINE_INFO_TABLE_INCREMENT * sizeof (dw_line_info_entry));
line_info_table_allocated = LINE_INFO_TABLE_INCREMENT;
/* Zero-th entry is allocated, but unused */

16
gcc/dwarf2out_020422.c
View File

@ -1950,7 +1950,7 @@ dwarf2out_frame_init ()
/* Allocate the initial hunk of the fde_table. */
fde_table
= (dw_fde_ref) xmalloc (FDE_TABLE_INCREMENT * sizeof (dw_fde_node));
bzero ((char *) fde_table, FDE_TABLE_INCREMENT * sizeof (dw_fde_node));
zero_memory ((char *) fde_table, FDE_TABLE_INCREMENT * sizeof (dw_fde_node));
fde_table_allocated = FDE_TABLE_INCREMENT;
fde_table_in_use = 0;
@ -4179,7 +4179,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],
zero_memory ((char *) &decl_die_table[decl_die_table_allocated],
(num_allocated - decl_die_table_allocated) * sizeof (dw_die_ref));
decl_die_table_allocated = num_allocated;
}
@ -4451,7 +4451,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],
zero_memory ((char *) &abbrev_die_table[abbrev_die_table_allocated],
(n_alloc - abbrev_die_table_allocated) * sizeof (dw_die_ref));
abbrev_die_table_allocated = n_alloc;
}
@ -9764,7 +9764,7 @@ dwarf2out_init (asm_out_file, main_input_filename)
/* Allocate the initial hunk of the file_table. */
file_table = (char **) xmalloc (FILE_TABLE_INCREMENT * sizeof (char *));
bzero ((char *) file_table, FILE_TABLE_INCREMENT * sizeof (char *));
zero_memory ((char *) file_table, FILE_TABLE_INCREMENT * sizeof (char *));
file_table_allocated = FILE_TABLE_INCREMENT;
/* Skip the first entry - file numbers begin at 1. */
@ -9773,7 +9773,7 @@ dwarf2out_init (asm_out_file, main_input_filename)
/* Allocate the initial hunk of the decl_die_table. */
decl_die_table
= (dw_die_ref *) xmalloc (DECL_DIE_TABLE_INCREMENT * sizeof (dw_die_ref));
bzero ((char *) decl_die_table,
zero_memory ((char *) decl_die_table,
DECL_DIE_TABLE_INCREMENT * sizeof (dw_die_ref));
decl_die_table_allocated = DECL_DIE_TABLE_INCREMENT;
decl_die_table_in_use = 0;
@ -9782,7 +9782,7 @@ dwarf2out_init (asm_out_file, main_input_filename)
decl_scope_table
= (decl_scope_node *) xmalloc (DECL_SCOPE_TABLE_INCREMENT
* sizeof (decl_scope_node));
bzero ((char *) decl_scope_table,
zero_memory ((char *) decl_scope_table,
DECL_SCOPE_TABLE_INCREMENT * sizeof (decl_scope_node));
decl_scope_table_allocated = DECL_SCOPE_TABLE_INCREMENT;
decl_scope_depth = 0;
@ -9791,7 +9791,7 @@ dwarf2out_init (asm_out_file, main_input_filename)
abbrev_die_table
= (dw_die_ref *) xmalloc (ABBREV_DIE_TABLE_INCREMENT
* sizeof (dw_die_ref));
bzero ((char *) abbrev_die_table,
zero_memory ((char *) abbrev_die_table,
ABBREV_DIE_TABLE_INCREMENT * sizeof (dw_die_ref));
abbrev_die_table_allocated = ABBREV_DIE_TABLE_INCREMENT;
/* Zero-th entry is allocated, but unused */
@ -9801,7 +9801,7 @@ dwarf2out_init (asm_out_file, main_input_filename)
line_info_table
= (dw_line_info_ref) xmalloc (LINE_INFO_TABLE_INCREMENT
* sizeof (dw_line_info_entry));
bzero ((char *) line_info_table,
zero_memory ((char *) line_info_table,
LINE_INFO_TABLE_INCREMENT * sizeof (dw_line_info_entry));
line_info_table_allocated = LINE_INFO_TABLE_INCREMENT;
/* Zero-th entry is allocated, but unused */

24
gcc/emit-rtl.c
View File

@ -539,19 +539,19 @@ gen_reg_rtx (mode)
rtx *new1;
char *new =
(char *) savealloc (regno_pointer_flag_length * 2);
bcopy (regno_pointer_flag, new, regno_pointer_flag_length);
bzero (&new[regno_pointer_flag_length], regno_pointer_flag_length);
copy_memory (regno_pointer_flag, new, regno_pointer_flag_length);
zero_memory (&new[regno_pointer_flag_length], regno_pointer_flag_length);
regno_pointer_flag = new;
new = (char *) savealloc (regno_pointer_flag_length * 2);
bcopy (regno_pointer_align, new, regno_pointer_flag_length);
bzero (&new[regno_pointer_flag_length], regno_pointer_flag_length);
copy_memory (regno_pointer_align, new, regno_pointer_flag_length);
zero_memory (&new[regno_pointer_flag_length], regno_pointer_flag_length);
regno_pointer_align = new;
new1 = (rtx *) savealloc (regno_pointer_flag_length * 2 * sizeof (rtx));
bcopy ((char *) regno_reg_rtx, (char *) new1,
copy_memory ((char *) regno_reg_rtx, (char *) new1,
regno_pointer_flag_length * sizeof (rtx));
bzero ((char *) &new1[regno_pointer_flag_length],
zero_memory ((char *) &new1[regno_pointer_flag_length],
regno_pointer_flag_length * sizeof (rtx));
regno_reg_rtx = new1;
@ -1767,7 +1767,7 @@ copy_rtx_if_shared (orig)
register rtx copy;
copy = rtx_alloc (code);
bcopy ((char *) x, (char *) copy,
copy_memory ((char *) x, (char *) copy,
(sizeof (*copy) - sizeof (copy->fld)
+ sizeof (copy->fld[0]) * GET_RTX_LENGTH (code)));
x = copy;
@ -3408,15 +3408,15 @@ init_emit ()
regno_pointer_flag
= (char *) savealloc (regno_pointer_flag_length);
bzero (regno_pointer_flag, regno_pointer_flag_length);
zero_memory (regno_pointer_flag, regno_pointer_flag_length);
regno_pointer_align
= (char *) savealloc (regno_pointer_flag_length);
bzero (regno_pointer_align, regno_pointer_flag_length);
zero_memory (regno_pointer_align, regno_pointer_flag_length);
regno_reg_rtx
= (rtx *) savealloc (regno_pointer_flag_length * sizeof (rtx));
bzero ((char *) regno_reg_rtx, regno_pointer_flag_length * sizeof (rtx));
zero_memory ((char *) regno_reg_rtx, regno_pointer_flag_length * sizeof (rtx));
/* Put copies of all the virtual register rtx into regno_reg_rtx. */
init_virtual_regs ();
@ -3532,10 +3532,10 @@ 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. */
zero_memory ((char *) &u, 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);
copy_memory ((char *) &u, (char *) &CONST_DOUBLE_LOW (tem), sizeof u);
CONST_DOUBLE_MEM (tem) = cc0_rtx;
PUT_MODE (tem, mode);

4
gcc/expmed.c
View File

@ -2289,9 +2289,9 @@ synth_mult (alg_out, t, cost_limit)
best_alg is normally undefined, and this is a critical function. */
alg_out->ops = best_alg->ops + 1;
alg_out->cost = cost_limit;
bcopy ((char *) best_alg->op, (char *) alg_out->op,
copy_memory ((char *) best_alg->op, (char *) alg_out->op,
alg_out->ops * sizeof *alg_out->op);
bcopy ((char *) best_alg->log, (char *) alg_out->log,
copy_memory ((char *) best_alg->log, (char *) alg_out->log,
alg_out->ops * sizeof *alg_out->log);
}

54
gcc/expr.c
View File

@ -1652,10 +1652,8 @@ emit_block_move (x, y, size, align)
int align;
{
rtx retval = 0;
#ifdef TARGET_MEM_FUNCTIONS
static tree fn;
tree call_expr, arg_list;
#endif
if (GET_MODE (x) != BLKmode)
abort ();
@ -1727,7 +1725,6 @@ emit_block_move (x, y, size, align)
}
}
#ifdef TARGET_MEM_FUNCTIONS
/* It is incorrect to use the libcall calling conventions to call
memcpy in this context.
@ -1782,14 +1779,6 @@ emit_block_move (x, y, size, align)
TREE_SIDE_EFFECTS (call_expr) = 1;
retval = expand_expr (call_expr, NULL_RTX, VOIDmode, 0);
#else
emit_library_call (bcopy_libfunc, 0,
VOIDmode, 3, XEXP (y, 0), Pmode,
XEXP (x, 0), Pmode,
convert_to_mode (TYPE_MODE (integer_type_node), size,
TREE_UNSIGNED (integer_type_node)),
TYPE_MODE (integer_type_node));
#endif
}
return retval;
@ -2395,10 +2384,8 @@ clear_storage (object, size, align)
rtx size;
int align;
{
#ifdef TARGET_MEM_FUNCTIONS
static tree fn;
tree call_expr, arg_list;
#endif
rtx retval = 0;
if (GET_MODE (object) == BLKmode)
@ -2462,7 +2449,6 @@ clear_storage (object, size, align)
}
#ifdef TARGET_MEM_FUNCTIONS
/* It is incorrect to use the libcall calling conventions to call
memset in this context.
@ -2517,15 +2503,6 @@ clear_storage (object, size, align)
TREE_SIDE_EFFECTS (call_expr) = 1;
retval = expand_expr (call_expr, NULL_RTX, VOIDmode, 0);
#else
emit_library_call (bzero_libfunc, 0,
VOIDmode, 2,
XEXP (object, 0), Pmode,
convert_to_mode
(TYPE_MODE (integer_type_node), size,
TREE_UNSIGNED (integer_type_node)),
TYPE_MODE (integer_type_node));
#endif
}
}
else
@ -3085,20 +3062,11 @@ emit_push_insn (x, mode, type, size, align, partial, reg, extra,
/* Make inhibit_defer_pop nonzero around the library call
to force it to pop the bcopy-arguments right away. */
NO_DEFER_POP;
#ifdef TARGET_MEM_FUNCTIONS
emit_library_call (memcpy_libfunc, 0,
VOIDmode, 3, temp, Pmode, XEXP (xinner, 0), Pmode,
convert_to_mode (TYPE_MODE (sizetype),
size, TREE_UNSIGNED (sizetype)),
TYPE_MODE (sizetype));
#else
emit_library_call (bcopy_libfunc, 0,
VOIDmode, 3, XEXP (xinner, 0), Pmode, temp, Pmode,
convert_to_mode (TYPE_MODE (integer_type_node),
size,
TREE_UNSIGNED (integer_type_node)),
TYPE_MODE (integer_type_node));
#endif
OK_DEFER_POP;
}
}
@ -3496,21 +3464,12 @@ expand_assignment (to, from, want_value, suggest_reg)
size, TREE_UNSIGNED (sizetype)),
TYPE_MODE (sizetype));
#ifdef TARGET_MEM_FUNCTIONS
emit_library_call (memcpy_libfunc, 0,
VOIDmode, 3, XEXP (to_rtx, 0), Pmode,
XEXP (from_rtx, 0), Pmode,
convert_to_mode (TYPE_MODE (sizetype),
size, TREE_UNSIGNED (sizetype)),
TYPE_MODE (sizetype));
#else
emit_library_call (bcopy_libfunc, 0,
VOIDmode, 3, XEXP (from_rtx, 0), Pmode,
XEXP (to_rtx, 0), Pmode,
convert_to_mode (TYPE_MODE (integer_type_node),
size, TREE_UNSIGNED (integer_type_node)),
TYPE_MODE (integer_type_node));
#endif
preserve_temp_slots (to_rtx);
free_temp_slots ();
@ -3831,7 +3790,6 @@ store_expr (exp, target, want_value)
size, TYPE_MODE (sizetype),
GEN_INT (MEMORY_USE_WO),
TYPE_MODE (integer_type_node));
#ifdef TARGET_MEM_FUNCTIONS
emit_library_call (memset_libfunc, 0, VOIDmode, 3,
addr, ptr_mode,
const0_rtx, TYPE_MODE (integer_type_node),
@ -3839,14 +3797,6 @@ store_expr (exp, target, want_value)
size,
TREE_UNSIGNED (sizetype)),
TYPE_MODE (sizetype));
#else
emit_library_call (bzero_libfunc, 0, VOIDmode, 2,
addr, ptr_mode,
convert_to_mode (TYPE_MODE (integer_type_node),
size,
TREE_UNSIGNED (integer_type_node)),
TYPE_MODE (integer_type_node));
#endif
}
if (label)
@ -4487,9 +4437,7 @@ store_constructor (exp, target, cleared)
tree startbit = TREE_PURPOSE (elt);
/* end of range of element, or element value */
tree endbit = TREE_VALUE (elt);
#ifdef TARGET_MEM_FUNCTIONS
HOST_WIDE_INT startb, endb;
#endif
rtx bitlength_rtx, startbit_rtx, endbit_rtx, targetx;
bitlength_rtx = expand_expr (bitlength,
@ -4525,7 +4473,6 @@ store_constructor (exp, target, cleared)
else
abort ();
#ifdef TARGET_MEM_FUNCTIONS
/* Optimization: If startbit and endbit are
constants divisible by BITS_PER_UNIT,
call memset instead. */
@ -4544,7 +4491,6 @@ store_constructor (exp, target, cleared)
TYPE_MODE (sizetype));
}
else
#endif
{
emit_library_call (gen_rtx_SYMBOL_REF (Pmode, "__setbits"),
0, VOIDmode, 4, XEXP (targetx, 0), Pmode,

3
gcc/expr.h
View File

@ -457,11 +457,8 @@ extern rtx truncxfdf2_libfunc;
extern rtx trunctfdf2_libfunc;
extern rtx memcpy_libfunc;
extern rtx bcopy_libfunc;
extern rtx memcmp_libfunc;
extern rtx bcmp_libfunc;
extern rtx memset_libfunc;
extern rtx bzero_libfunc;
extern rtx throw_libfunc;
extern rtx rethrow_libfunc;

10
gcc/final.c
View File

@ -734,7 +734,7 @@ shorten_branches (first)
min_labelno = get_first_label_num ();
label_align = (struct label_alignment *) xmalloc (
(max_labelno - min_labelno + 1) * sizeof (struct label_alignment));
bzero ((char *) label_align,
zero_memory ((char *) label_align,
(max_labelno - min_labelno + 1) * sizeof (struct label_alignment));
uid_shuid = (int *) xmalloc (max_uid * sizeof *uid_shuid);
@ -859,12 +859,12 @@ shorten_branches (first)
insn_lengths_max_uid = max_uid;
/* Syntax errors can lead to labels being outside of the main insn stream.
Initialize insn_addresses, so that we get reproducible results. */
bzero ((char *)insn_addresses, max_uid * sizeof *insn_addresses);
zero_memory ((char *)insn_addresses, max_uid * sizeof *insn_addresses);
uid_align = (rtx *) xmalloc (max_uid * sizeof *uid_align);
varying_length = (char *) xmalloc (max_uid * sizeof (char));
bzero (varying_length, max_uid);
zero_memory (varying_length, max_uid);
/* Initialize uid_align. We scan instructions
from end to start, and keep in align_tab[n] the last seen insn
@ -872,7 +872,7 @@ shorten_branches (first)
in the alignment chain for an insn that does / has a known
alignment of n. */
bzero ((char *) uid_align, max_uid * sizeof *uid_align);
zero_memory ((char *) uid_align, max_uid * sizeof *uid_align);
for (i = MAX_CODE_ALIGN; --i >= 0; )
align_tab[i] = NULL_RTX;
@ -1427,7 +1427,7 @@ final (first, file, optimize, prescan)
max_line = NOTE_LINE_NUMBER (insn);
line_note_exists = (char *) oballoc (max_line + 1);
bzero (line_note_exists, max_line + 1);
zero_memory (line_note_exists, max_line + 1);
for (insn = first; insn; insn = NEXT_INSN (insn))
{

34
gcc/flow.c
View File

@ -400,14 +400,14 @@ find_basic_blocks (f, nregs, file)
x_basic_block_end = XNMALLOC (rtx, n_basic_blocks);
basic_block_succ = XNMALLOC (int_list_ptr, n_basic_blocks);
basic_block_pred = XNMALLOC (int_list_ptr, n_basic_blocks);
bzero ((char *)basic_block_succ, n_basic_blocks * sizeof (int_list_ptr));
bzero ((char *)basic_block_pred, n_basic_blocks * sizeof (int_list_ptr));
zero_memory ((char *)basic_block_succ, n_basic_blocks * sizeof (int_list_ptr));
zero_memory ((char *)basic_block_pred, n_basic_blocks * sizeof (int_list_ptr));
basic_block_computed_jump_target = (char *) oballoc (n_basic_blocks);
basic_block_loop_depth = XNMALLOC (short, n_basic_blocks);
uid_block_number = XNMALLOC (int, (max_uid_for_flow + 1));
uid_volatile = XNMALLOC (char, (max_uid_for_flow + 1));
bzero (uid_volatile, max_uid_for_flow + 1);
zero_memory (uid_volatile, max_uid_for_flow + 1);
find_basic_blocks_1 (f, nonlocal_label_list);
}
@ -458,11 +458,11 @@ find_basic_blocks_1 (f, nonlocal_labels)
label_value_list = 0;
block_live_static = block_live;
bzero (block_live, n_basic_blocks);
bzero (block_marked, n_basic_blocks);
bzero (basic_block_computed_jump_target, n_basic_blocks);
bzero ((char *) active_eh_region, (max_uid_for_flow + 1) * sizeof (int));
bzero ((char *) nested_eh_region, (max_label_num () + 1) * sizeof (int));
zero_memory (block_live, n_basic_blocks);
zero_memory (block_marked, n_basic_blocks);
zero_memory (basic_block_computed_jump_target, n_basic_blocks);
zero_memory ((char *) active_eh_region, (max_uid_for_flow + 1) * sizeof (int));
zero_memory ((char *) nested_eh_region, (max_label_num () + 1) * sizeof (int));
current_function_has_computed_jump = 0;
/* Initialize with just block 0 reachable and no blocks marked. */
@ -1415,9 +1415,9 @@ life_analysis_1 (f, nregs)
Reload will make some registers as live even though they do not appear
in the rtl. */
if (reload_completed)
bcopy (regs_ever_live, save_regs_ever_live, (sizeof (regs_ever_live)));
copy_memory (regs_ever_live, save_regs_ever_live, (sizeof (regs_ever_live)));
bzero (regs_ever_live, sizeof regs_ever_live);
zero_memory (regs_ever_live, sizeof regs_ever_live);
/* Allocate and zero out many data structures
that will record the data from lifetime analysis. */
@ -1425,7 +1425,7 @@ life_analysis_1 (f, nregs)
allocate_for_life_analysis ();
reg_next_use = (rtx *) alloca (nregs * sizeof (rtx));
bzero ((char *) reg_next_use, nregs * sizeof (rtx));
zero_memory ((char *) reg_next_use, nregs * sizeof (rtx));
/* Set up several regset-vectors used internally within this function.
Their meanings are documented above, with their declarations. */
@ -1634,7 +1634,7 @@ life_analysis_1 (f, nregs)
/* Restore regs_ever_live that was provided by reload. */
if (reload_completed)
bcopy (save_regs_ever_live, regs_ever_live, (sizeof (regs_ever_live)));
copy_memory (save_regs_ever_live, regs_ever_live, (sizeof (regs_ever_live)));
free_regset_vector (basic_block_live_at_end, n_basic_blocks);
free_regset_vector (basic_block_new_live_at_end, n_basic_blocks);
@ -3570,10 +3570,10 @@ compute_preds_succs (s_preds, s_succs, num_preds, num_succs, split_edges)
int bb;
int changed = 0;
bzero ((char *) s_preds, n_basic_blocks * sizeof (int_list_ptr));
bzero ((char *) s_succs, n_basic_blocks * sizeof (int_list_ptr));
bzero ((char *) num_preds, n_basic_blocks * sizeof (int));
bzero ((char *) num_succs, n_basic_blocks * sizeof (int));
zero_memory ((char *) s_preds, n_basic_blocks * sizeof (int_list_ptr));
zero_memory ((char *) s_succs, n_basic_blocks * sizeof (int_list_ptr));
zero_memory ((char *) num_preds, n_basic_blocks * sizeof (int));
zero_memory ((char *) num_succs, n_basic_blocks * sizeof (int));
/* It's somewhat stupid to simply copy the information. The passes
which use this function ought to be changed to refer directly to
@ -3611,7 +3611,7 @@ compute_preds_succs (s_preds, s_succs, num_preds, num_succs, split_edges)
to any given block from being split. */
char *split_edge_to_block = (char *) alloca (n_basic_blocks);
bzero (split_edge_to_block, n_basic_blocks);
zero_memory (split_edge_to_block, n_basic_blocks);
for (bb = 0; bb < n_basic_blocks; bb++)
{

10
gcc/fold-const.c
View File

@ -305,7 +305,7 @@ mul_double (l1, h1, l2, h2, lv, hv)
encode (arg1, l1, h1);
encode (arg2, l2, h2);
bzero ((char *) prod, sizeof prod);
zero_memory ((char *) prod, sizeof prod);
for (i = 0; i < 4; i++)
{
@ -528,10 +528,10 @@ div_and_round_double (code, uns,
goto finish_up;
}
bzero ((char *) quo, sizeof quo);
zero_memory ((char *) quo, sizeof quo);
bzero ((char *) num, sizeof num); /* to zero 9th element */
bzero ((char *) den, sizeof den);
zero_memory ((char *) num, sizeof num); /* to zero 9th element */
zero_memory ((char *) den, sizeof den);
encode (num, lnum, hnum);
encode (den, lden, hden);
@ -4317,7 +4317,7 @@ reduce_expression_tree_depth (code, type, arg0, arg1)
int n_ops;
int i, j, changed;
bzero ((char *)ops, sizeof ops);
zero_memory ((char *)ops, sizeof ops);
/* Place our operands into the expression array. */
ops[0] = arg0;

6
gcc/function.c
View File

@ -3980,7 +3980,7 @@ assign_parms (fndecl, second_time)
max_parm_reg = LAST_VIRTUAL_REGISTER + 1;
parm_reg_stack_loc = (rtx *) savealloc (max_parm_reg * sizeof (rtx));
bzero ((char *) parm_reg_stack_loc, max_parm_reg * sizeof (rtx));
zero_memory ((char *) parm_reg_stack_loc, max_parm_reg * sizeof (rtx));
#ifdef INIT_CUMULATIVE_INCOMING_ARGS
INIT_CUMULATIVE_INCOMING_ARGS (args_so_far, fntype, NULL_RTX);
@ -4558,9 +4558,9 @@ assign_parms (fndecl, second_time)
precisely correct. */
max_parm_reg = regno + 1;
new = (rtx *) savealloc (max_parm_reg * sizeof (rtx));
bcopy ((char *) parm_reg_stack_loc, (char *) new,
copy_memory ((char *) parm_reg_stack_loc, (char *) new,
old_max_parm_reg * sizeof (rtx));
bzero ((char *) (new + old_max_parm_reg),
zero_memory ((char *) (new + old_max_parm_reg),
(max_parm_reg - old_max_parm_reg) * sizeof (rtx));
parm_reg_stack_loc = new;
}

6
gcc/function_990206.c
View File

@ -3980,7 +3980,7 @@ assign_parms (fndecl, second_time)
max_parm_reg = LAST_VIRTUAL_REGISTER + 1;
parm_reg_stack_loc = (rtx *) savealloc (max_parm_reg * sizeof (rtx));
bzero ((char *) parm_reg_stack_loc, max_parm_reg * sizeof (rtx));
zero_memory ((char *) parm_reg_stack_loc, max_parm_reg * sizeof (rtx));
#ifdef INIT_CUMULATIVE_INCOMING_ARGS
INIT_CUMULATIVE_INCOMING_ARGS (args_so_far, fntype, NULL_RTX);
@ -4558,9 +4558,9 @@ assign_parms (fndecl, second_time)
precisely correct. */
max_parm_reg = regno + 1;
new = (rtx *) savealloc (max_parm_reg * sizeof (rtx));
bcopy ((char *) parm_reg_stack_loc, (char *) new,
copy_memory ((char *) parm_reg_stack_loc, (char *) new,
old_max_parm_reg * sizeof (rtx));
bzero ((char *) (new + old_max_parm_reg),
zero_memory ((char *) (new + old_max_parm_reg),
(max_parm_reg - old_max_parm_reg) * sizeof (rtx));
parm_reg_stack_loc = new;
}

34
gcc/gcc.c
View File

@ -1058,7 +1058,7 @@ translate_options (argcp, argvp)
/* If this mapping requires extra text at end of name,
accept that as "argument". */
else if (index (arginfo, '*') != 0)
else if (strchr (arginfo, '*') != 0)
arg = argv[i] + optlen;
/* Otherwise, extra text at end means mismatch.
@ -1067,14 +1067,14 @@ translate_options (argcp, argvp)
continue;
}
else if (index (arginfo, '*') != 0)
else if (strchr (arginfo, '*') != 0)
{
error ("Incomplete `%s' option", option_map[j].name);
break;
}
/* Handle arguments. */
if (index (arginfo, 'a') != 0)
if (strchr (arginfo, 'a') != 0)
{
if (arg == 0)
{
@ -1088,9 +1088,9 @@ translate_options (argcp, argvp)
arg = argv[++i];
}
}
else if (index (arginfo, '*') != 0)
else if (strchr (arginfo, '*') != 0)
;
else if (index (arginfo, 'o') == 0)
else if (strchr (arginfo, 'o') == 0)
{
if (arg != 0)
error ("Extraneous argument to `%s' option",
@ -1099,7 +1099,7 @@ translate_options (argcp, argvp)
}
/* Store the translation as one argv elt or as two. */
if (arg != 0 && index (arginfo, 'j') != 0)
if (arg != 0 && strchr (arginfo, 'j') != 0)
newv[newindex++] = concat (option_map[j].equivalent, arg,
NULL_PTR);
else if (arg != 0)
@ -1286,7 +1286,7 @@ init_spec ()
extra_specs = (struct spec_list *)
xmalloc (sizeof(struct spec_list) *
(sizeof(extra_specs_1)/sizeof(extra_specs_1[0])));
bzero ((PTR) extra_specs, sizeof(struct spec_list) *
zero_memory ((PTR) extra_specs, sizeof(struct spec_list) *
(sizeof(extra_specs_1)/sizeof(extra_specs_1[0])));
for (i = (sizeof(extra_specs_1) / sizeof(extra_specs_1[0])) - 1; i >= 0; i--)
@ -1786,11 +1786,11 @@ read_specs (filename, main_p)
(n_compilers + 2) * sizeof (struct compiler)));
compilers[n_compilers].suffix = suffix;
bzero ((char *) compilers[n_compilers].spec,
zero_memory ((char *) compilers[n_compilers].spec,
sizeof compilers[n_compilers].spec);
compilers[n_compilers].spec[0] = spec;
n_compilers++;
bzero ((char *) &compilers[n_compilers],
zero_memory ((char *) &compilers[n_compilers],
sizeof compilers[n_compilers]);
}
@ -3593,7 +3593,7 @@ process_command (argc, argv)
/* Null-terminate the vector. */
switches[n_switches].args[j] = 0;
}
else if (index (switches_need_spaces, c))
else if (strchr (switches_need_spaces, c))
{
/* On some systems, ld cannot handle some options without
a space. So split the option from its argument. */
@ -5076,7 +5076,7 @@ main (argc, argv)
first_time = FALSE;
obstack_grow (&collect_obstack, "'-", 2);
q = switches[i].part1;
while ((p = index (q,'\'')))
while ((p = strchr (q,'\'')))
{
obstack_grow (&collect_obstack, q, p-q);
obstack_grow (&collect_obstack, "'\\''", 4);
@ -5089,7 +5089,7 @@ main (argc, argv)
{
obstack_grow (&collect_obstack, " '", 2);
q = *args;
while ((p = index (q,'\'')))
while ((p = strchr (q,'\'')))
{
obstack_grow (&collect_obstack, q, p-q);
obstack_grow (&collect_obstack, "'\\''", 4);
@ -5107,7 +5107,7 @@ main (argc, argv)
This means one element containing 0s, as a terminator. */
compilers = (struct compiler *) xmalloc (sizeof default_compilers);
bcopy ((char *) default_compilers, (char *) compilers,
copy_memory ((char *) default_compilers, (char *) compilers,
sizeof default_compilers);
n_compilers = n_default_compilers;
@ -5339,12 +5339,12 @@ main (argc, argv)
i += lang_specific_extra_outfiles;
#endif
outfiles = (char **) xmalloc (i * sizeof (char *));
bzero ((char *) outfiles, i * sizeof (char *));
zero_memory ((char *) outfiles, i * sizeof (char *));
/* Record which files were specified explicitly as link input. */
explicit_link_files = xmalloc (n_infiles);
bzero (explicit_link_files, n_infiles);
zero_memory (explicit_link_files, n_infiles);
for (i = 0; (int)i < n_infiles; i++)
{
@ -5540,7 +5540,7 @@ lookup_compiler (name, length, language)
language = cp->spec[0] + 1;
new = (struct compiler *) xmalloc (sizeof (struct compiler));
new->suffix = cp->suffix;
bcopy ((char *) lookup_compiler (NULL_PTR, 0, language)->spec,
copy_memory ((char *) lookup_compiler (NULL_PTR, 0, language)->spec,
(char *) new->spec, sizeof new->spec);
return new;
}
@ -5585,7 +5585,7 @@ save_string (s, len)
{
register char *result = xmalloc (len + 1);
bcopy (s, result, len);
copy_memory (s, result, len);
result[len] = 0;
return result;
}

30
gcc/gcse.c
View File

@ -829,7 +829,7 @@ compute_can_copy ()
rtx reg,insn;
char *free_point = (char *) oballoc (1);
bzero (can_copy_p, NUM_MACHINE_MODES);
zero_memory (can_copy_p, NUM_MACHINE_MODES);
start_sequence ();
for (i = 0; i < NUM_MACHINE_MODES; i++)
@ -909,7 +909,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);
zero_memory ((char *) uid_cuid, n);
for (insn = f, i = 0; insn; insn = NEXT_INSN (insn))
{
if (GET_RTX_CLASS (GET_CODE (insn)) == 'i')
@ -923,7 +923,7 @@ alloc_gcse_mem (f)
max_cuid = i;
n = (max_cuid + 1) * sizeof (rtx);
cuid_insn = (rtx *) gmalloc (n);
bzero ((char *) cuid_insn, n);
zero_memory ((char *) cuid_insn, n);
for (insn = f, i = 0; insn; insn = NEXT_INSN (insn))
{
if (GET_RTX_CLASS (GET_CODE (insn)) == 'i')
@ -1085,7 +1085,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);
zero_memory ((char *) reg_set_table, n);
gcc_obstack_init (&reg_set_obstack);
}
@ -1114,7 +1114,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),
zero_memory ((char *) (reg_set_table + reg_set_table_size),
(new_size - reg_set_table_size) * sizeof (struct reg_set *));
reg_set_table_size = new_size;
}
@ -2078,7 +2078,7 @@ dump_hash_table (file, name, table, table_size, total_size)
struct expr **flat_table = (struct expr **) alloca (total_size * sizeof (struct expr *));
unsigned int *hash_val = (unsigned int *) alloca (total_size * sizeof (unsigned int));
bzero ((char *) flat_table, total_size * sizeof (struct expr *));
zero_memory ((char *) flat_table, total_size * sizeof (struct expr *));
for (i = 0; i < table_size; i++)
{
struct expr *expr;
@ -2188,7 +2188,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 ((rtx *) modify_mem_list, n_basic_blocks * sizeof (rtx *));
zero_memory ((rtx *) modify_mem_list, n_basic_blocks * sizeof (rtx *));
/* 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
@ -2313,7 +2313,7 @@ compute_set_hash_table ()
{
/* Initialize count of number of entries in hash table. */
n_sets = 0;
bzero ((char *) set_hash_table, set_hash_table_size * sizeof (struct expr *));
zero_memory ((char *) set_hash_table, set_hash_table_size * sizeof (struct expr *));
compute_hash_table (1);
}
@ -2355,7 +2355,7 @@ compute_expr_hash_table ()
{
/* Initialize count of number of entries in hash table. */
n_exprs = 0;
bzero ((char *) expr_hash_table, expr_hash_table_size * sizeof (struct expr *));
zero_memory ((char *) expr_hash_table, expr_hash_table_size * sizeof (struct expr *));
compute_hash_table (0);
}
@ -2439,7 +2439,7 @@ reset_opr_set_tables ()
/* Also keep a record of the last instruction to modify memory.
For now this is very trivial, we only record whether any memory
location has been modified. */
bzero ((char *)modify_mem_list, n_basic_blocks * sizeof (rtx *));
zero_memory ((char *)modify_mem_list, n_basic_blocks * sizeof (rtx *));
}
/* Return non-zero if the operands of X are not set before INSN in
@ -3002,7 +3002,7 @@ expr_reaches_here_p (occr, expr, bb, check_self_loop, visited)
if (visited == NULL)
{
visited = (char *) alloca (n_basic_blocks);
bzero (visited, n_basic_blocks);
zero_memory (visited, n_basic_blocks);
}
for (pred = s_preds[bb]; pred != NULL; pred = pred->next)
@ -4183,7 +4183,7 @@ pre_expr_reaches_here_p (occr_bb, expr, bb, check_pre_comp, visited)
if (visited == NULL)
{
visited = (char *) alloca (n_basic_blocks);
bzero (visited, n_basic_blocks);
zero_memory (visited, n_basic_blocks);
}
for (pred = s_preds[bb]; pred != NULL; pred = pred->next)
@ -4636,7 +4636,7 @@ pre_gcse ()
hash table entry. */
index_map = (struct expr **) alloca (n_exprs * sizeof (struct expr *));
bzero ((char *) index_map, n_exprs * sizeof (struct expr *));
zero_memory ((char *) index_map, n_exprs * sizeof (struct expr *));
for (i = 0; i < expr_hash_table_size; i++)
{
struct expr *expr;
@ -4887,7 +4887,7 @@ hoist_expr_reaches_here_p (expr_bb, expr_index, bb, visited)
if (visited == NULL)
{
visited = (char *) alloca (n_basic_blocks);
bzero (visited, n_basic_blocks);
zero_memory (visited, n_basic_blocks);
}
visited[expr_bb] = 1;
@ -4930,7 +4930,7 @@ hoist_code ()
hash table entry. */
index_map = (struct expr **) alloca (n_exprs * sizeof (struct expr *));
bzero ((char *) index_map, n_exprs * sizeof (struct expr *));
zero_memory ((char *) index_map, n_exprs * sizeof (struct expr *));
for (i = 0; i < expr_hash_table_size; i++)
{
struct expr *expr;

2
gcc/genattr.c
View File

@ -361,7 +361,7 @@ from the machine description file `md'. */\n\n");
unit = (struct function_unit *)
alloca (sizeof (struct function_unit));
unit->name = (char *) alloca (len);
bcopy (name, unit->name, len);
copy_memory (name, unit->name, len);
unit->multiplicity = multiplicity;
unit->simultaneity = simultaneity;
unit->ready_cost.min = unit->ready_cost.max = ready_cost;

12
gcc/genattrtab.c
View File

@ -800,7 +800,7 @@ attr_string (str, len)
/* Not found; create a permanent copy and add it to the hash table. */
new_str = (char *) obstack_alloc (hash_obstack, len + 1);
bcopy (str, new_str, len);
copy_memory (str, new_str, len);
new_str[len] = '\0';
attr_hash_add_string (hashcode, new_str);
@ -1939,7 +1939,7 @@ expand_units ()
* sizeof (struct function_unit_op *));
for (unit = units, i = 0; unit; i += unit->num_opclasses, unit = unit->next)
bcopy ((char *) unit_ops[unit->num], (char *) &op_array[i],
copy_memory ((char *) unit_ops[unit->num], (char *) &op_array[i],
unit->num_opclasses * sizeof (struct function_unit_op *));
/* Compute the ready cost function for each unit by computing the
@ -2507,7 +2507,7 @@ simplify_cond (exp, insn_code, insn_index)
/* This lets us free all storage allocated below, if appropriate. */
first_spacer = (char *) obstack_finish (rtl_obstack);
bcopy ((char *) XVEC (exp, 0)->elem, (char *) tests, len * sizeof (rtunion));
copy_memory ((char *) XVEC (exp, 0)->elem, (char *) tests, len * sizeof (rtunion));
/* See if default value needs simplification. */
if (GET_CODE (defval) == COND)
@ -2599,7 +2599,7 @@ simplify_cond (exp, insn_code, insn_index)
rtx newexp = rtx_alloc (COND);
XVEC (newexp, 0) = rtvec_alloc (len);
bcopy ((char *) tests, (char *) XVEC (newexp, 0)->elem,
copy_memory ((char *) tests, (char *) XVEC (newexp, 0)->elem,
len * sizeof (rtunion));
XEXP (newexp, 1) = new_defval;
return newexp;
@ -3416,7 +3416,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,
zero_memory ((char *) insn_code_values,
(insn_code_number + 2) * sizeof (struct attr_value_list *));
/* Offset the table address so we can index by -2 or -1. */
@ -5811,7 +5811,7 @@ copy_rtx_unchanging (orig)
PUT_MODE (copy, GET_MODE (orig));
RTX_UNCHANGING_P (copy) = 1;
bcopy ((char *) &XEXP (orig, 0), (char *) &XEXP (copy, 0),
copy_memory ((char *) &XEXP (orig, 0), (char *) &XEXP (copy, 0),
GET_RTX_LENGTH (GET_CODE (copy)) * sizeof (rtx));
return copy;
#endif

2
gcc/gengenrtl.c
View File

@ -268,7 +268,7 @@ gencode (f)
fputs ("static rtx obstack_alloc_rtx (length)\n", f);
fputs (" register int length;\n{\n", f);
fputs (" rtx rt = (rtx) obstack_alloc (rtl_obstack, length);\n\n", f);
fputs (" bzero((char *) rt, sizeof(struct rtx_def) - sizeof(rtunion));\n\n", f);
fputs (" zero_memory((char *) rt, sizeof(struct rtx_def) - sizeof(rtunion));\n\n", f);
fputs (" return rt;\n}\n\n", f);
for (fmt = formats; *fmt; ++fmt)

2
gcc/genrecog.c
View File

@ -225,7 +225,7 @@ make_insn_sequence (insn, type)
int new_size;
new_size = (insn_name_ptr_size ? insn_name_ptr_size * 2 : 512);
insn_name_ptr = xrealloc (insn_name_ptr, sizeof(char *) * new_size);
bzero (insn_name_ptr + insn_name_ptr_size,
zero_memory (insn_name_ptr + insn_name_ptr_size,
sizeof(char *) * (new_size - insn_name_ptr_size));
insn_name_ptr_size = new_size;
}

28
gcc/global.c
View File

@ -346,7 +346,7 @@ global_init (FILE *file)
from the list of pairs that may share. */
reg_may_share = (int *) obstack_alloc (&global_obstack, max_regno * sizeof (int));
bzero ((char *) reg_may_share, max_regno * sizeof (int));
zero_memory ((char *) reg_may_share, max_regno * sizeof (int));
for (x = regs_may_share; x; x = XEXP (XEXP (x, 1), 1))
{
int r1 = REGNO (XEXP (x, 0));
@ -383,10 +383,10 @@ global_init (FILE *file)
allocno_n_refs = (int *) obstack_alloc (&global_obstack, max_allocno * sizeof (int));
allocno_live_length = (int *) obstack_alloc (&global_obstack, max_allocno * sizeof (int));
bzero ((char *) allocno_size, max_allocno * sizeof (int));
bzero ((char *) allocno_calls_crossed, max_allocno * sizeof (int));
bzero ((char *) allocno_n_refs, max_allocno * sizeof (int));
bzero ((char *) allocno_live_length, max_allocno * sizeof (int));
zero_memory ((char *) allocno_size, max_allocno * sizeof (int));
zero_memory ((char *) allocno_calls_crossed, max_allocno * sizeof (int));
zero_memory ((char *) allocno_n_refs, max_allocno * sizeof (int));
zero_memory ((char *) allocno_live_length, max_allocno * sizeof (int));
for (i = FIRST_PSEUDO_REGISTER; i < (size_t) max_regno; i++)
if (reg_allocno[i] >= 0)
@ -403,8 +403,8 @@ global_init (FILE *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);
zero_memory ((char *) local_reg_live_length, sizeof local_reg_live_length);
zero_memory ((char *) local_reg_n_refs, sizeof local_reg_n_refs);
for (i = FIRST_PSEUDO_REGISTER; i < (size_t) max_regno; i++)
if (reg_renumber[i] >= 0)
{
@ -460,14 +460,14 @@ global_init (FILE *file)
(allocno_row_words
* sizeof (INT_TYPE)));
bzero ((char *) hard_reg_conflicts, max_allocno * sizeof (HARD_REG_SET));
bzero ((char *) hard_reg_preferences, max_allocno * sizeof (HARD_REG_SET));
bzero ((char *) hard_reg_copy_preferences,
zero_memory ((char *) hard_reg_conflicts, max_allocno * sizeof (HARD_REG_SET));
zero_memory ((char *) hard_reg_preferences, max_allocno * sizeof (HARD_REG_SET));
zero_memory ((char *) hard_reg_copy_preferences,
max_allocno * sizeof (HARD_REG_SET));
bzero ((char *) hard_reg_full_preferences,
zero_memory ((char *) hard_reg_full_preferences,
max_allocno * sizeof (HARD_REG_SET));
bzero ((char *) regs_someone_prefers, max_allocno * sizeof (HARD_REG_SET));
bzero ((char *) conflicts,
zero_memory ((char *) regs_someone_prefers, max_allocno * sizeof (HARD_REG_SET));
zero_memory ((char *) conflicts,
max_allocno * allocno_row_words * sizeof (INT_TYPE));
/* If there is work to be done (at least one reg to allocate),
@ -651,7 +651,7 @@ global_conflicts ()
for (b = 0; b < n_basic_blocks; b++)
{
bzero ((char *) allocnos_live, allocno_row_words * sizeof (INT_TYPE));
zero_memory ((char *) allocnos_live, allocno_row_words * sizeof (INT_TYPE));
/* Initialize table of registers currently live
to the state at the beginning of this basic block.

22
gcc/integrate.c
View File

@ -300,7 +300,7 @@ initialize_for_inline (fndecl, min_labelno, max_labelno, max_reg, copy)
+ current_function_uses_pic_offset_table * FUNCTION_FLAGS_USES_PIC_OFFSET_TABLE);
/* Clear out PARMDECL_MAP. It was allocated in the caller's frame. */
bzero ((char *) parmdecl_map, max_parm_reg * sizeof (tree));
zero_memory ((char *) parmdecl_map, max_parm_reg * sizeof (tree));
arg_vector = rtvec_alloc (list_length (DECL_ARGUMENTS (fndecl)));
for (parms = DECL_ARGUMENTS (fndecl), i = 0;
@ -589,7 +589,7 @@ save_for_inline_copying (fndecl)
/* Record the mapping of old insns to copied insns. */
insn_map = (rtx *) alloca (max_uid * sizeof (rtx));
bzero ((char *) insn_map, max_uid * sizeof (rtx));
zero_memory ((char *) insn_map, max_uid * sizeof (rtx));
/* Get the insn which signals the end of parameter setup code. */
first_nonparm_insn = get_first_nonparm_insn ();
@ -607,7 +607,7 @@ save_for_inline_copying (fndecl)
/* Copy the parm_reg_stack_loc array, and substitute for all of the rtx
contained in it. */
new2 = (rtx *) savealloc (max_parm_reg * sizeof (rtx));
bcopy ((char *) parm_reg_stack_loc, (char *) new2,
copy_memory ((char *) parm_reg_stack_loc, (char *) new2,
max_parm_reg * sizeof (rtx));
parm_reg_stack_loc = new2;
for (i = LAST_VIRTUAL_REGISTER + 1; i < max_parm_reg; ++i)
@ -732,9 +732,9 @@ save_for_inline_copying (fndecl)
/* Make new versions of the register tables. */
new = (char *) savealloc (regno_pointer_flag_length);
bcopy (regno_pointer_flag, new, regno_pointer_flag_length);
copy_memory (regno_pointer_flag, new, regno_pointer_flag_length);
new1 = (char *) savealloc (regno_pointer_flag_length);
bcopy (regno_pointer_align, new1, regno_pointer_flag_length);
copy_memory (regno_pointer_align, new1, regno_pointer_flag_length);
regno_pointer_flag = new;
regno_pointer_align = new1;
@ -1242,7 +1242,7 @@ copy_for_inline (orig)
/* Replace this rtx with a copy of itself. */
x = rtx_alloc (code);
bcopy ((char *) orig, (char *) x,
copy_memory ((char *) orig, (char *) x,
(sizeof (*x) - sizeof (x->fld)
+ sizeof (x->fld[0]) * GET_RTX_LENGTH (code)));
@ -1532,7 +1532,7 @@ expand_inline_function (fndecl, parms, target, ignore, type,
map->fndecl = fndecl;
map->reg_map = (rtx *) alloca (max_regno * sizeof (rtx));
bzero ((char *) map->reg_map, max_regno * sizeof (rtx));
zero_memory ((char *) map->reg_map, max_regno * sizeof (rtx));
/* We used to use alloca here, but the size of what it would try to
allocate would occasionally cause it to exceed the stack limit and
@ -1542,7 +1542,7 @@ expand_inline_function (fndecl, parms, target, ignore, type,
map->label_map = real_label_map;
map->insn_map = (rtx *) alloca (INSN_UID (header) * sizeof (rtx));
bzero ((char *) map->insn_map, INSN_UID (header) * sizeof (rtx));
zero_memory ((char *) map->insn_map, INSN_UID (header) * sizeof (rtx));
map->min_insnno = 0;
map->max_insnno = INSN_UID (header);
@ -1565,12 +1565,12 @@ expand_inline_function (fndecl, parms, target, ignore, type,
map->const_equiv_map
= (rtx *)alloca (map->const_equiv_map_size * sizeof (rtx));
bzero ((char *) map->const_equiv_map,
zero_memory ((char *) map->const_equiv_map,
map->const_equiv_map_size * sizeof (rtx));
map->const_age_map
= (unsigned *)alloca (map->const_equiv_map_size * sizeof (unsigned));
bzero ((char *) map->const_age_map,
zero_memory ((char *) map->const_age_map,
map->const_equiv_map_size * sizeof (unsigned));
map->const_age = 0;
@ -1834,7 +1834,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],
zero_memory ((char *) &map->label_map [min_labelno],
(max_labelno - min_labelno) * sizeof (rtx));
/* Perform postincrements before actually calling the function. */

10
gcc/jump.c
View File

@ -208,7 +208,7 @@ jump_optimize (f, cross_jump, noop_moves, after_regscan)
we make. */
max_jump_chain = max_uid * 14 / 10;
jump_chain = (rtx *) alloca (max_jump_chain * sizeof (rtx));
bzero ((char *) jump_chain, max_jump_chain * sizeof (rtx));
zero_memory ((char *) jump_chain, max_jump_chain * sizeof (rtx));
mark_all_labels (f, cross_jump);
@ -2666,7 +2666,7 @@ duplicate_loop_exit_test (loop_start)
if (reg_map == 0)
{
reg_map = (rtx *) alloca (max_reg * sizeof (rtx));
bzero ((char *) reg_map, max_reg * sizeof (rtx));
zero_memory ((char *) reg_map, max_reg * sizeof (rtx));
}
REG_LOOP_TEST_P (reg) = 1;
@ -4726,10 +4726,10 @@ thread_jumps (f, max_reg, flag_before_loop)
|| JUMP_LABEL (b1) == 0)
continue;
bzero (modified_regs, max_reg * sizeof (char));
zero_memory (modified_regs, max_reg * sizeof (char));
modified_mem = 0;
bcopy ((char *) all_reset, (char *) same_regs,
copy_memory ((char *) all_reset, (char *) same_regs,
max_reg * sizeof (int));
num_same_regs = 0;
@ -5240,7 +5240,7 @@ conditional_execution (insn)
rtx seq;
fix_insns = (cexec *) alloca (sizeof (cexec) * max);
bzero ((char *)fix_insns, sizeof (cexec) * max);
zero_memory ((char *)fix_insns, sizeof (cexec) * max);
true_false = (XEXP (SET_SRC (PATTERN (insn)), 1) != pc_rtx);
for (p = next_nonnote_insn (insn); ; p = next_nonnote_insn (p))

12
gcc/local-alloc.c
View File

@ -375,7 +375,7 @@ local_alloc ()
vectors might need to be initialized because they were used
for the previous block; it is set to the entire array before
block 0. Initialize those, with explicit loop if there are few,
else with bzero and bcopy. Do not initialize vectors that are
else with zero_memory and bcopy. Do not initialize vectors that are
explicit set by `alloc_qty'. */
if (next_qty < 6)
@ -391,7 +391,7 @@ local_alloc ()
else
{
#define CLEAR(vector) \
bzero ((char *) (vector), (sizeof (*(vector))) * next_qty);
zero_memory ((char *) (vector), (sizeof (*(vector))) * next_qty);
CLEAR (qty_phys_copy_sugg);
CLEAR (qty_phys_num_copy_sugg);
@ -667,9 +667,9 @@ update_equiv_regs ()
reg_equiv_init_insns = (rtx *) alloca (max_regno * sizeof (rtx));
reg_equiv_replacement = (rtx *) alloca (max_regno * sizeof (rtx));
bzero ((char *) reg_equiv_init_insns, max_regno * sizeof (rtx));
bzero ((char *) reg_equiv_replacement, max_regno * sizeof (rtx));
bzero ((char *) reg_equiv_replace, max_regno * sizeof *reg_equiv_replace);
zero_memory ((char *) reg_equiv_init_insns, max_regno * sizeof (rtx));
zero_memory ((char *) reg_equiv_replacement, max_regno * sizeof (rtx));
zero_memory ((char *) reg_equiv_replace, max_regno * sizeof *reg_equiv_replace);
init_alias_analysis ();
@ -1035,7 +1035,7 @@ block_alloc (b)
the birth of a CLOBBER in the first insn. */
regs_live_at = (HARD_REG_SET *) alloca ((2 * insn_count + 2)
* sizeof (HARD_REG_SET));
bzero ((char *) regs_live_at, (2 * insn_count + 2) * sizeof (HARD_REG_SET));
zero_memory ((char *) regs_live_at, (2 * insn_count + 2) * sizeof (HARD_REG_SET));
/* Initialize table of hardware registers currently live. */

36
gcc/loop.c
View File

@ -471,7 +471,7 @@ loop_optimize (f, dumpfile, unroll_p, bct_p)
max_reg_before_loop = max_reg_num ();
moved_once = (char *) alloca (max_reg_before_loop);
bzero (moved_once, max_reg_before_loop);
zero_memory (moved_once, max_reg_before_loop);
regs_may_share = 0;
@ -496,8 +496,8 @@ loop_optimize (f, dumpfile, unroll_p, bct_p)
uid_luid = (int *) alloca (max_uid_for_loop * sizeof (int));
uid_loop_num = (int *) alloca (max_uid_for_loop * sizeof (int));
bzero ((char *) uid_luid, max_uid_for_loop * sizeof (int));
bzero ((char *) uid_loop_num, max_uid_for_loop * sizeof (int));
zero_memory ((char *) uid_luid, max_uid_for_loop * sizeof (int));
zero_memory ((char *) uid_loop_num, max_uid_for_loop * sizeof (int));
/* Allocate tables for recording each loop. We set each entry, so they need
not be zeroed. */
@ -513,7 +513,7 @@ loop_optimize (f, dumpfile, unroll_p, bct_p)
#ifdef HAVE_decrement_and_branch_on_count
/* Allocate for BCT optimization */
loop_used_count_register = (int *) alloca (max_loop_num * sizeof (int));
bzero ((char *) loop_used_count_register, max_loop_num * sizeof (int));
zero_memory ((char *) loop_used_count_register, max_loop_num * sizeof (int));
#endif /* HAVE_decrement_and_branch_on_count */
/* Find and process each loop.
@ -776,7 +776,7 @@ scan_loop (loop_start, end, loop_cont, unroll_p, bct_p)
VARRAY_CHAR (may_not_optimize, i) = 1;
#endif
bcopy ((char *) &set_in_loop->data,
copy_memory ((char *) &set_in_loop->data,
(char *) &n_times_set->data, nregs * sizeof (int));
if (loop_dump_stream)
@ -1458,7 +1458,7 @@ combine_movables (movables, nregs)
register struct movable *m1;
int regno = m->regno;
bzero (matched_regs, nregs);
zero_memory (matched_regs, nregs);
matched_regs[regno] = 1;
/* We want later insns to match the first one. Don't make the first
@ -1752,8 +1752,8 @@ move_movables (movables, threshold, insn_count, loop_start, end, nregs)
rtx *reg_map = (rtx *) alloca (nregs * sizeof (rtx));
char *already_moved = (char *) alloca (nregs);
bzero (already_moved, nregs);
bzero ((char *) reg_map, nregs * sizeof (rtx));
zero_memory (already_moved, nregs);
zero_memory ((char *) reg_map, nregs * sizeof (rtx));
num_movables = 0;
@ -3506,7 +3506,7 @@ count_loop_regs_set (from, to, may_not_move, single_usage, count_ptr, nregs)
register rtx insn;
register int count = 0;
bzero ((char *) last_set, nregs * sizeof (rtx));
zero_memory ((char *) last_set, nregs * sizeof (rtx));
for (insn = from; insn != to; insn = NEXT_INSN (insn))
{
if (GET_RTX_CLASS (GET_CODE (insn)) == 'i')
@ -3536,7 +3536,7 @@ count_loop_regs_set (from, to, 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));
zero_memory ((char *) last_set, nregs * sizeof (rtx));
}
*count_ptr = count;
}
@ -3710,7 +3710,7 @@ strength_reduce (scan_start, end, loop_top, insn_count,
VARRAY_GENERIC_PTR_INIT (reg_iv_info, max_reg_before_loop, "reg_iv_info");
reg_biv_class = (struct iv_class **)
alloca (max_reg_before_loop * sizeof (struct iv_class *));
bzero ((char *) reg_biv_class, (max_reg_before_loop
zero_memory ((char *) reg_biv_class, (max_reg_before_loop
* sizeof (struct iv_class *)));
loop_iv_list = 0;
@ -4463,7 +4463,7 @@ strength_reduce (scan_start, end, loop_top, insn_count,
reg_iv_type for a suitable size. */
reg_map_size = reg_iv_type->num_elements;
reg_map = (rtx *) alloca (reg_map_size * sizeof (rtx));
bzero ((char *) reg_map, reg_map_size * sizeof (rtx));
zero_memory ((char *) reg_map, reg_map_size * sizeof (rtx));
/* Examine each iv class for feasibility of strength reduction/induction
variable elimination. */
@ -6845,10 +6845,10 @@ combine_givs (bl)
giv_array[i++] = g1;
stats = (struct combine_givs_stats *) alloca (giv_count * sizeof (*stats));
bzero ((char *) stats, giv_count * sizeof (*stats));
zero_memory ((char *) stats, giv_count * sizeof (*stats));
can_combine = (rtx *) alloca (giv_count * giv_count * sizeof(rtx));
bzero ((char *) can_combine, giv_count * giv_count * sizeof(rtx));
zero_memory ((char *) can_combine, giv_count * giv_count * sizeof(rtx));
for (i = 0; i < giv_count; i++)
{
@ -9259,10 +9259,10 @@ load_mems_and_recount_loop_regs_set (scan_start, end, loop_top, start,
VARRAY_GROW (reg_single_usage, nregs);
}
/* Clear the arrays */
bzero ((char *) &set_in_loop->data, nregs * sizeof (int));
bzero ((char *) &may_not_optimize->data, nregs * sizeof (char));
zero_memory ((char *) &set_in_loop->data, nregs * sizeof (int));
zero_memory ((char *) &may_not_optimize->data, nregs * sizeof (char));
if (reg_single_usage)
bzero ((char *) &reg_single_usage->data, nregs * sizeof (rtx));
zero_memory ((char *) &reg_single_usage->data, nregs * sizeof (rtx));
count_loop_regs_set (loop_top ? loop_top : start, end,
may_not_optimize, reg_single_usage,
@ -9283,7 +9283,7 @@ load_mems_and_recount_loop_regs_set (scan_start, end, loop_top, start,
#endif
/* Set n_times_set for the new registers. */
bcopy ((char *) (&set_in_loop->data.i[0] + old_nregs),
copy_memory ((char *) (&set_in_loop->data.i[0] + old_nregs),
(char *) (&n_times_set->data.i[0] + old_nregs),
(nregs - old_nregs) * sizeof (int));
}

36
gcc/loop_990401.c
View File

@ -471,7 +471,7 @@ loop_optimize (f, dumpfile, unroll_p, bct_p)
max_reg_before_loop = max_reg_num ();
moved_once = (char *) alloca (max_reg_before_loop);
bzero (moved_once, max_reg_before_loop);
zero_memory (moved_once, max_reg_before_loop);
regs_may_share = 0;
@ -496,8 +496,8 @@ loop_optimize (f, dumpfile, unroll_p, bct_p)
uid_luid = (int *) alloca (max_uid_for_loop * sizeof (int));
uid_loop_num = (int *) alloca (max_uid_for_loop * sizeof (int));
bzero ((char *) uid_luid, max_uid_for_loop * sizeof (int));
bzero ((char *) uid_loop_num, max_uid_for_loop * sizeof (int));
zero_memory ((char *) uid_luid, max_uid_for_loop * sizeof (int));
zero_memory ((char *) uid_loop_num, max_uid_for_loop * sizeof (int));
/* Allocate tables for recording each loop. We set each entry, so they need
not be zeroed. */
@ -513,7 +513,7 @@ loop_optimize (f, dumpfile, unroll_p, bct_p)
#ifdef HAVE_decrement_and_branch_on_count
/* Allocate for BCT optimization */
loop_used_count_register = (int *) alloca (max_loop_num * sizeof (int));
bzero ((char *) loop_used_count_register, max_loop_num * sizeof (int));
zero_memory ((char *) loop_used_count_register, max_loop_num * sizeof (int));
#endif /* HAVE_decrement_and_branch_on_count */
/* Find and process each loop.
@ -776,7 +776,7 @@ scan_loop (loop_start, end, loop_cont, unroll_p, bct_p)
VARRAY_CHAR (may_not_optimize, i) = 1;
#endif
bcopy ((char *) &set_in_loop->data,
copy_memory ((char *) &set_in_loop->data,
(char *) &n_times_set->data, nregs * sizeof (int));
if (loop_dump_stream)
@ -1458,7 +1458,7 @@ combine_movables (movables, nregs)
register struct movable *m1;
int regno = m->regno;
bzero (matched_regs, nregs);
zero_memory (matched_regs, nregs);
matched_regs[regno] = 1;
/* We want later insns to match the first one. Don't make the first
@ -1752,8 +1752,8 @@ move_movables (movables, threshold, insn_count, loop_start, end, nregs)
rtx *reg_map = (rtx *) alloca (nregs * sizeof (rtx));
char *already_moved = (char *) alloca (nregs);
bzero (already_moved, nregs);
bzero ((char *) reg_map, nregs * sizeof (rtx));
zero_memory (already_moved, nregs);
zero_memory ((char *) reg_map, nregs * sizeof (rtx));
num_movables = 0;
@ -3506,7 +3506,7 @@ count_loop_regs_set (from, to, may_not_move, single_usage, count_ptr, nregs)
register rtx insn;
register int count = 0;
bzero ((char *) last_set, nregs * sizeof (rtx));
zero_memory ((char *) last_set, nregs * sizeof (rtx));
for (insn = from; insn != to; insn = NEXT_INSN (insn))
{
if (GET_RTX_CLASS (GET_CODE (insn)) == 'i')
@ -3536,7 +3536,7 @@ count_loop_regs_set (from, to, 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));
zero_memory ((char *) last_set, nregs * sizeof (rtx));
}
*count_ptr = count;
}
@ -3710,7 +3710,7 @@ strength_reduce (scan_start, end, loop_top, insn_count,
VARRAY_GENERIC_PTR_INIT (reg_iv_info, max_reg_before_loop, "reg_iv_info");
reg_biv_class = (struct iv_class **)
alloca (max_reg_before_loop * sizeof (struct iv_class *));
bzero ((char *) reg_biv_class, (max_reg_before_loop
zero_memory ((char *) reg_biv_class, (max_reg_before_loop
* sizeof (struct iv_class *)));
loop_iv_list = 0;
@ -4463,7 +4463,7 @@ strength_reduce (scan_start, end, loop_top, insn_count,
reg_iv_type for a suitable size. */
reg_map_size = reg_iv_type->num_elements;
reg_map = (rtx *) alloca (reg_map_size * sizeof (rtx));
bzero ((char *) reg_map, reg_map_size * sizeof (rtx));
zero_memory ((char *) reg_map, reg_map_size * sizeof (rtx));
/* Examine each iv class for feasibility of strength reduction/induction
variable elimination. */
@ -6845,10 +6845,10 @@ combine_givs (bl)
giv_array[i++] = g1;
stats = (struct combine_givs_stats *) alloca (giv_count * sizeof (*stats));
bzero ((char *) stats, giv_count * sizeof (*stats));
zero_memory ((char *) stats, giv_count * sizeof (*stats));
can_combine = (rtx *) alloca (giv_count * giv_count * sizeof(rtx));
bzero ((char *) can_combine, giv_count * giv_count * sizeof(rtx));
zero_memory ((char *) can_combine, giv_count * giv_count * sizeof(rtx));
for (i = 0; i < giv_count; i++)
{
@ -9258,10 +9258,10 @@ load_mems_and_recount_loop_regs_set (scan_start, end, loop_top, start,
VARRAY_GROW (reg_single_usage, nregs);
}
/* Clear the arrays */
bzero ((char *) &set_in_loop->data, nregs * sizeof (int));
bzero ((char *) &may_not_optimize->data, nregs * sizeof (char));
zero_memory ((char *) &set_in_loop->data, nregs * sizeof (int));
zero_memory ((char *) &may_not_optimize->data, nregs * sizeof (char));
if (reg_single_usage)
bzero ((char *) &reg_single_usage->data, nregs * sizeof (rtx));
zero_memory ((char *) &reg_single_usage->data, nregs * sizeof (rtx));
count_loop_regs_set (loop_top ? loop_top : start, end,
may_not_optimize, reg_single_usage,
@ -9282,7 +9282,7 @@ load_mems_and_recount_loop_regs_set (scan_start, end, loop_top, start,
#endif
/* Set n_times_set for the new registers. */
bcopy ((char *) (&set_in_loop->data.i[0] + old_nregs),
copy_memory ((char *) (&set_in_loop->data.i[0] + old_nregs),
(char *) (&n_times_set->data.i[0] + old_nregs),
(nregs - old_nregs) * sizeof (int));
}

16
gcc/optabs.c
View File

@ -116,11 +116,8 @@ rtx truncxfdf2_libfunc;
rtx trunctfdf2_libfunc;
rtx memcpy_libfunc;
rtx bcopy_libfunc;
rtx memcmp_libfunc;
rtx bcmp_libfunc;
rtx memset_libfunc;
rtx bzero_libfunc;
rtx throw_libfunc;
rtx rethrow_libfunc;
@ -2809,22 +2806,12 @@ emit_cmp_insn (x, y, comparison, size, mode, unsignedp, align)
{
rtx result;
#ifdef TARGET_MEM_FUNCTIONS
emit_library_call (memcmp_libfunc, 0,
TYPE_MODE (integer_type_node), 3,
XEXP (x, 0), Pmode, XEXP (y, 0), Pmode,
convert_to_mode (TYPE_MODE (sizetype), size,
TREE_UNSIGNED (sizetype)),
TYPE_MODE (sizetype));
#else
emit_library_call (bcmp_libfunc, 0,
TYPE_MODE (integer_type_node), 3,
XEXP (x, 0), Pmode, XEXP (y, 0), Pmode,
convert_to_mode (TYPE_MODE (integer_type_node),
size,
TREE_UNSIGNED (integer_type_node)),
TYPE_MODE (integer_type_node));
#endif
/* Immediately move the result of the libcall into a pseudo
register so reload doesn't clobber the value if it needs
@ -4365,11 +4352,8 @@ init_optabs ()
trunctfdf2_libfunc = gen_rtx_SYMBOL_REF (Pmode, "__trunctfdf2");
memcpy_libfunc = gen_rtx_SYMBOL_REF (Pmode, "memcpy");
bcopy_libfunc = gen_rtx_SYMBOL_REF (Pmode, "bcopy");
memcmp_libfunc = gen_rtx_SYMBOL_REF (Pmode, "memcmp");
bcmp_libfunc = gen_rtx_SYMBOL_REF (Pmode, "__gcc_bcmp");
memset_libfunc = gen_rtx_SYMBOL_REF (Pmode, "memset");
bzero_libfunc = gen_rtx_SYMBOL_REF (Pmode, "bzero");
throw_libfunc = gen_rtx_SYMBOL_REF (Pmode, "__throw");
rethrow_libfunc = gen_rtx_SYMBOL_REF (Pmode, "__rethrow");

2
gcc/prefix.c
View File

@ -171,7 +171,7 @@ save_string (s, len)
{
register char *result = xmalloc (len + 1);
bcopy (s, result, len);
copy_memory (s, result, len);
result[len] = 0;
return result;
}

2
gcc/print-tree.c
View File

@ -52,7 +52,7 @@ debug_tree (node)
char *object = (char *) oballoc (0);
table = (struct bucket **) oballoc (HASH_SIZE * sizeof (struct bucket *));
bzero ((char *) table, HASH_SIZE * sizeof (struct bucket *));
zero_memory ((char *) table, HASH_SIZE * sizeof (struct bucket *));
print_node (stderr, "", node, 0);
table = 0;
obfree (object);

975
gcc/real.c
View File

File diff suppressed because it is too large Load Diff

115
gcc/real.h
View File

@ -30,13 +30,9 @@ Boston, MA 02111-1307, USA. */
/* Default to IEEE float if not specified. Nearly all machines use it. */
#ifndef TARGET_FLOAT_FORMAT
#define TARGET_FLOAT_FORMAT IEEE_FLOAT_FORMAT
#endif
#ifndef HOST_FLOAT_FORMAT
#define HOST_FLOAT_FORMAT IEEE_FLOAT_FORMAT
#endif
#if TARGET_FLOAT_FORMAT == IEEE_FLOAT_FORMAT
#define REAL_INFINITY
@ -64,56 +60,11 @@ Boston, MA 02111-1307, USA. */
that can produce a target machine format differing by more
than just endian-ness from the host's format. The emulator
is also used to support extended real XFmode. */
#ifndef LONG_DOUBLE_TYPE_SIZE
#define LONG_DOUBLE_TYPE_SIZE 64
#endif
#if (LONG_DOUBLE_TYPE_SIZE == 96) || (LONG_DOUBLE_TYPE_SIZE == 128)
#ifndef REAL_ARITHMETIC
#define REAL_ARITHMETIC
#endif
#endif
#ifdef REAL_ARITHMETIC
/* **** Start of software floating point emulator interface macros **** */
/* Support 80-bit extended real XFmode if LONG_DOUBLE_TYPE_SIZE
has been defined to be 96 in the tm.h machine file. */
#if (LONG_DOUBLE_TYPE_SIZE == 96)
#define REAL_IS_NOT_DOUBLE
#define REAL_ARITHMETIC
typedef struct {
HOST_WIDE_INT r[(11 + sizeof (HOST_WIDE_INT))/(sizeof (HOST_WIDE_INT))];
} realvaluetype;
#define REAL_VALUE_TYPE realvaluetype
#else /* no XFmode support */
#if (LONG_DOUBLE_TYPE_SIZE == 128)
#define REAL_IS_NOT_DOUBLE
#define REAL_ARITHMETIC
typedef struct {
HOST_WIDE_INT r[(19 + sizeof (HOST_WIDE_INT))/(sizeof (HOST_WIDE_INT))];
} realvaluetype;
#define REAL_VALUE_TYPE realvaluetype
#else /* not TFmode */
#if HOST_FLOAT_FORMAT != TARGET_FLOAT_FORMAT
/* If no XFmode support, then a REAL_VALUE_TYPE is 64 bits wide
but it is not necessarily a host machine double. */
#define REAL_IS_NOT_DOUBLE
typedef struct {
HOST_WIDE_INT r[(7 + sizeof (HOST_WIDE_INT))/(sizeof (HOST_WIDE_INT))];
} realvaluetype;
#define REAL_VALUE_TYPE realvaluetype
#else
/* If host and target formats are compatible, then a REAL_VALUE_TYPE
is actually a host machine double. */
#define REAL_VALUE_TYPE double
#endif
#endif /* no TFmode support */
#endif /* no XFmode support */
extern int significand_size PROTO((enum machine_mode));
@ -122,7 +73,6 @@ extern int significand_size PROTO((enum machine_mode));
they invoke emulator functions. This will succeed only if the machine
files have been updated to use these macros in place of any
references to host machine `double' or `float' types. */
#ifdef REAL_ARITHMETIC
#undef REAL_ARITHMETIC
#define REAL_ARITHMETIC(value, code, d1, d2) \
earith (&(value), (code), &(d1), &(d2))
@ -198,11 +148,7 @@ extern REAL_VALUE_TYPE real_value_truncate PROTO ((enum machine_mode,
ereal_from_uint (&d, lo, hi, mode)
/* IN is a REAL_VALUE_TYPE. OUT is an array of longs. */
#if LONG_DOUBLE_TYPE_SIZE == 96
#define REAL_VALUE_TO_TARGET_LONG_DOUBLE(IN, OUT) (etarldouble ((IN), (OUT)))
#else
#define REAL_VALUE_TO_TARGET_LONG_DOUBLE(IN, OUT) (etartdouble ((IN), (OUT)))
#endif
#define REAL_VALUE_TO_TARGET_DOUBLE(IN, OUT) (etardouble ((IN), (OUT)))
/* IN is a REAL_VALUE_TYPE. OUT is a long. */
@ -224,45 +170,7 @@ extern REAL_VALUE_TYPE real_value_truncate PROTO ((enum machine_mode,
/* Conversions to decimal ASCII string. */
#define REAL_VALUE_TO_DECIMAL(r, fmt, s) (ereal_to_decimal (r, s))
#endif /* REAL_ARITHMETIC defined */
/* **** End of software floating point emulator interface macros **** */
#else /* No XFmode or TFmode and REAL_ARITHMETIC not defined */
/* old interface */
#ifdef REAL_ARITHMETIC
/* Defining REAL_IS_NOT_DOUBLE breaks certain initializations
when REAL_ARITHMETIC etc. are not defined. */
/* Now see if the host and target machines use the same format.
If not, define REAL_IS_NOT_DOUBLE (even if we end up representing
reals as doubles because we have no better way in this cross compiler.)
This turns off various optimizations that can happen when we know the
compiler's float format matches the target's float format.
*/
#if HOST_FLOAT_FORMAT != TARGET_FLOAT_FORMAT
#define REAL_IS_NOT_DOUBLE
#ifndef REAL_VALUE_TYPE
typedef struct {
HOST_WIDE_INT r[sizeof (double)/sizeof (HOST_WIDE_INT)];
} realvaluetype;
#define REAL_VALUE_TYPE realvaluetype
#endif /* no REAL_VALUE_TYPE */
#endif /* formats differ */
#endif /* 0 */
#endif /* emulator not used */
/* If we are not cross-compiling, use a `double' to represent the
floating-point value. Otherwise, use some other type
(probably a struct containing an array of longs). */
#ifndef REAL_VALUE_TYPE
#define REAL_VALUE_TYPE double
#else
#define REAL_IS_NOT_DOUBLE
#endif
#if HOST_FLOAT_FORMAT == TARGET_FLOAT_FORMAT
/* Convert a type `double' value in host format first to a type `float'
value in host format and then to a single type `long' value which
@ -302,19 +210,13 @@ do { \
(OUT)[1] = u.l[0], (OUT)[0] = u.l[1]; \
} while (0)
#endif
#endif /* HOST_FLOAT_FORMAT == TARGET_FLOAT_FORMAT */
/* In this configuration, double and long double are the same. */
#ifndef REAL_VALUE_TO_TARGET_LONG_DOUBLE
#define REAL_VALUE_TO_TARGET_LONG_DOUBLE(a, b) REAL_VALUE_TO_TARGET_DOUBLE (a, b)
#endif
/* Compare two floating-point objects for bitwise identity.
This is not the same as comparing for equality on IEEE hosts:
-0.0 equals 0.0 but they are not identical, and conversely
two NaNs might be identical but they cannot be equal. */
#define REAL_VALUES_IDENTICAL(x, y) \
(!bcmp ((char *) &(x), (char *) &(y), sizeof (REAL_VALUE_TYPE)))
(!memcmp ((char *) &(x), (char *) &(y), sizeof (REAL_VALUE_TYPE)))
/* Compare two floating-point values for equality. */
#ifndef REAL_VALUES_EQUAL
@ -355,25 +257,12 @@ extern double ldexp ();
/* Convert the string X to a floating-point value. */
#ifndef REAL_VALUE_ATOF
#if 1
/* Use real.c to convert decimal numbers to binary, ... */
REAL_VALUE_TYPE ereal_atof ();
#define REAL_VALUE_ATOF(x, s) ereal_atof (x, s)
/* Could use ereal_atof here for hexadecimal floats too, but real_hex_to_f
is OK and it uses faster native fp arithmetic. */
/* #define REAL_VALUE_HTOF(x, s) ereal_atof (x, s) */
#else
/* ... or, if you like the host computer's atof, go ahead and use it: */
#define REAL_VALUE_ATOF(x, s) atof (x)
#if defined (MIPSEL) || defined (MIPSEB)
/* MIPS compiler can't handle parens around the function name.
This problem *does not* appear to be connected with any
macro definition for atof. It does not seem there is one. */
extern double atof ();
#else
extern double (atof) ();
#endif
#endif
#endif
/* Hexadecimal floating constant input for use with host computer's

2
gcc/recog.c
View File

@ -1804,7 +1804,7 @@ extract_insn (insn)
recog_n_alternatives += (*p++ == ',');
}
#ifndef REGISTER_CONSTRAINTS
bzero (recog_operand_address_p, sizeof recog_operand_address_p);
zero_memory (recog_operand_address_p, sizeof recog_operand_address_p);
#endif
break;
}

12
gcc/reg-stack.c
View File

@ -498,8 +498,8 @@ reg_to_stack (first, file)
block_stack_in = (stack) alloca (blocks * sizeof (struct stack_def));
block_out_reg_set = (HARD_REG_SET *) alloca (blocks * sizeof (HARD_REG_SET));
bzero ((char *) block_stack_in, blocks * sizeof (struct stack_def));
bzero ((char *) block_out_reg_set, blocks * sizeof (HARD_REG_SET));
zero_memory ((char *) block_stack_in, blocks * sizeof (struct stack_def));
zero_memory ((char *) block_out_reg_set, blocks * sizeof (HARD_REG_SET));
block_number = (int *) alloca ((max_uid + 1) * sizeof (int));
@ -688,7 +688,7 @@ record_asm_reg_life (insn, regstack)
Also enforce rule #5: Output operands must start at the top of
the reg-stack: output operands may not "skip" a reg. */
bzero ((char *) reg_used_as_output, sizeof (reg_used_as_output));
zero_memory ((char *) reg_used_as_output, sizeof (reg_used_as_output));
for (i = 0; i < n_outputs; i++)
if (STACK_REG_P (recog_operand[i]))
{
@ -722,7 +722,7 @@ record_asm_reg_life (insn, regstack)
to the top of the reg-stack than any input that is not implicitly
popped. */
bzero ((char *) implicitly_dies, sizeof (implicitly_dies));
zero_memory ((char *) implicitly_dies, sizeof (implicitly_dies));
for (i = n_outputs; i < n_outputs + n_inputs; i++)
if (STACK_REG_P (recog_operand[i]))
{
@ -2232,7 +2232,7 @@ subst_asm_stack_regs (insn, regstack)
}
}
bcopy ((char *) regstack, (char *) &temp_stack, sizeof (temp_stack));
copy_memory ((char *) regstack, (char *) &temp_stack, sizeof (temp_stack));
/* Put the input regs into the desired place in TEMP_STACK. */
@ -2531,7 +2531,7 @@ change_stack (insn, old, new, when)
the old stack order. */
new->top = old->top;
bcopy (old->reg, new->reg, sizeof (new->reg));
copy_memory (old->reg, new->reg, sizeof (new->reg));
}
else
{

20
gcc/regclass.c
View File

@ -207,7 +207,7 @@ static rtx top_of_stack[MAX_MACHINE_MODE];
/* Linked list of reg_info structures allocated for reg_n_info array.
Grouping all of the allocated structures together in one lump
means only one call to bzero to clear them, rather than n smaller
means only one call to zero_memory to clear them, rather than n smaller
calls. */
struct reg_info_data {
struct reg_info_data *next; /* next set of reg_info structures */
@ -241,9 +241,9 @@ init_reg_sets ()
SET_HARD_REG_BIT (reg_class_contents[i], j);
}
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);
copy_memory (initial_fixed_regs, fixed_regs, sizeof fixed_regs);
copy_memory (initial_call_used_regs, call_used_regs, sizeof call_used_regs);
zero_memory (global_regs, sizeof global_regs);
/* Do any additional initialization regsets may need */
INIT_ONCE_REG_SET ();
@ -266,7 +266,7 @@ init_reg_sets_1 ()
/* Compute number of hard regs in each class. */
bzero ((char *) reg_class_size, sizeof reg_class_size);
zero_memory ((char *) reg_class_size, 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))
@ -373,7 +373,7 @@ init_reg_sets_1 ()
CLEAR_HARD_REG_SET (call_used_reg_set);
CLEAR_HARD_REG_SET (call_fixed_reg_set);
bcopy (fixed_regs, call_fixed_regs, sizeof call_fixed_regs);
copy_memory (fixed_regs, call_fixed_regs, sizeof call_fixed_regs);
n_non_fixed_regs = 0;
@ -1038,10 +1038,10 @@ regclass (f, nregs)
{
/* Zero out our accumulation of the cost of each class for each reg. */
bzero ((char *) costs, nregs * sizeof (struct costs));
zero_memory ((char *) costs, nregs * sizeof (struct costs));
#ifdef FORBIDDEN_INC_DEC_CLASSES
bzero (in_inc_dec, nregs);
zero_memory (in_inc_dec, nregs);
#endif
loop_depth = 0, loop_cost = 1;
@ -1194,7 +1194,7 @@ record_reg_classes (n_alts, n_ops, ops, modes, constraints, insn)
if (*p == 0)
{
if (GET_CODE (op) == REG && REGNO (op) >= FIRST_PSEUDO_REGISTER)
bzero ((char *) &this_op_costs[i], sizeof this_op_costs[i]);
zero_memory ((char *) &this_op_costs[i], sizeof this_op_costs[i]);
continue;
}
@ -1894,7 +1894,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],
zero_memory ((char *) &reg_data->data[local_min],
sizeof (reg_info) * (max - min_index - local_min + 1));
for (i = min_index+local_min; i <= max; i++)

6
gcc/regmove.c
View File

@ -692,7 +692,7 @@ find_related (xp, insn, luid, call_tally)
new_related->invalidate_luid = 0;
new_related->death = NULL_RTX;
rel_new (new_related->baseinfo);
bzero ((char *) new_related->baseinfo,
zero_memory ((char *) new_related->baseinfo,
sizeof *new_related->baseinfo);
new_related->baseinfo->prev_base = rel_base_list;
rel_base_list = new_related;
@ -1508,7 +1508,7 @@ optimize_related_values_1 (rel_base, luid, call_tally, insert_after,
}
/* Finally, clear the entries that we used in regno_related. We do it
item by item here, because doing it with bzero for each basic block
item by item here, because doing it with zero_memory for each basic block
would give O(n*n) time complexity. */
for (rel = rel_base; rel; rel = rel->prev)
regno_related[REGNO (rel->reg)] = 0;
@ -1623,7 +1623,7 @@ optimize_related_values (nregs, regmove_dump_file)
gcc_obstack_init (&related_obstack);
regno_related = rel_alloc (nregs * sizeof *regno_related);
bzero ((char *) regno_related, nregs * sizeof *regno_related);
zero_memory ((char *) regno_related, nregs * sizeof *regno_related);
rel_base_list = 0;
loop_depth = 1;
for (insn = get_insns (); insn; insn = NEXT_INSN (insn))

12
gcc/reload.c
View File

@ -714,7 +714,7 @@ get_secondary_mem (x, mode, opnum, type)
void
clear_secondary_mem ()
{
bzero ((char *) secondary_memlocs, sizeof secondary_memlocs);
zero_memory ((char *) secondary_memlocs, sizeof secondary_memlocs);
}
#endif /* SECONDARY_MEMORY_NEEDED */
@ -1553,7 +1553,7 @@ remove_address_replacements (in_rtx)
char reload_flags[MAX_RELOADS];
int something_changed = 0;
bzero (reload_flags, sizeof reload_flags);
zero_memory (reload_flags, sizeof reload_flags);
for (i = 0, j = 0; i < n_replacements; i++)
{
if (loc_mentioned_in_p (replacements[i].where, in_rtx))
@ -2461,7 +2461,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);
zero_memory ((char *) secondary_memlocs_elim, sizeof secondary_memlocs_elim);
#endif
/* Dispose quickly of (set (reg..) (reg..)) if both have hard regs and it
@ -2488,9 +2488,9 @@ find_reloads (insn, replace, ind_levels, live_known, reload_reg_p)
insn_code_number = INSN_CODE (insn);
this_insn_is_asm = insn_code_number < 0;
bcopy ((char *) recog_operand_mode, (char *) operand_mode,
copy_memory ((char *) recog_operand_mode, (char *) operand_mode,
noperands * sizeof (enum machine_mode));
bcopy ((char *) recog_constraints, (char *) constraints,
copy_memory ((char *) recog_constraints, (char *) constraints,
noperands * sizeof (char *));
commutative = -1;
@ -3479,7 +3479,7 @@ find_reloads (insn, replace, ind_levels, live_known, reload_reg_p)
pref_or_nothing[commutative] = pref_or_nothing[commutative + 1];
pref_or_nothing[commutative + 1] = t;
bcopy ((char *) recog_constraints, (char *) constraints,
copy_memory ((char *) recog_constraints, (char *) constraints,
noperands * sizeof (char *));
goto try_swapped;
}

74
gcc/reload1.c
View File

@ -616,8 +616,8 @@ reload (first, global, dumpfile)
#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);
zero_memory ((char *) spill_stack_slot, sizeof spill_stack_slot);
zero_memory ((char *) spill_stack_slot_width, sizeof spill_stack_slot_width);
/* Initialize the save area information for caller-save, in case some
are needed. */
@ -650,26 +650,26 @@ reload (first, global, dumpfile)
be substituted eventually by altering the REG-rtx's. */
reg_equiv_constant = (rtx *) xmalloc (max_regno * sizeof (rtx));
bzero ((char *) reg_equiv_constant, max_regno * sizeof (rtx));
zero_memory ((char *) reg_equiv_constant, max_regno * sizeof (rtx));
reg_equiv_memory_loc = (rtx *) xmalloc (max_regno * sizeof (rtx));
bzero ((char *) reg_equiv_memory_loc, max_regno * sizeof (rtx));
zero_memory ((char *) reg_equiv_memory_loc, max_regno * sizeof (rtx));
reg_equiv_mem = (rtx *) xmalloc (max_regno * sizeof (rtx));
bzero ((char *) reg_equiv_mem, max_regno * sizeof (rtx));
zero_memory ((char *) reg_equiv_mem, max_regno * sizeof (rtx));
reg_equiv_init = (rtx *) xmalloc (max_regno * sizeof (rtx));
bzero ((char *) reg_equiv_init, max_regno * sizeof (rtx));
zero_memory ((char *) reg_equiv_init, max_regno * sizeof (rtx));
reg_equiv_address = (rtx *) xmalloc (max_regno * sizeof (rtx));
bzero ((char *) reg_equiv_address, max_regno * sizeof (rtx));
zero_memory ((char *) reg_equiv_address, max_regno * sizeof (rtx));
reg_max_ref_width = (int *) xmalloc (max_regno * sizeof (int));
bzero ((char *) reg_max_ref_width, max_regno * sizeof (int));
zero_memory ((char *) reg_max_ref_width, max_regno * sizeof (int));
reg_old_renumber = (short *) xmalloc (max_regno * sizeof (short));
bcopy (reg_renumber, reg_old_renumber, max_regno * sizeof (short));
copy_memory (reg_renumber, reg_old_renumber, max_regno * sizeof (short));
pseudo_forbidden_regs
= (HARD_REG_SET *) xmalloc (max_regno * sizeof (HARD_REG_SET));
pseudo_previous_regs
= (HARD_REG_SET *) xmalloc (max_regno * sizeof (HARD_REG_SET));
CLEAR_HARD_REG_SET (bad_spill_regs_global);
bzero ((char *) pseudo_previous_regs, max_regno * sizeof (HARD_REG_SET));
zero_memory ((char *) pseudo_previous_regs, max_regno * sizeof (HARD_REG_SET));
/* Look for REG_EQUIV notes; record what each pseudo is equivalent to.
Also find all paradoxical subregs and find largest such for each pseudo.
@ -1475,10 +1475,10 @@ calculate_needs (chain)
struct needs out_addr_addr[MAX_RECOG_OPERANDS];
} insn_needs;
bzero ((char *) chain->group_size, sizeof chain->group_size);
zero_memory ((char *) chain->group_size, sizeof chain->group_size);
for (i = 0; i < N_REG_CLASSES; i++)
chain->group_mode[i] = VOIDmode;
bzero ((char *) &insn_needs, sizeof insn_needs);
zero_memory ((char *) &insn_needs, sizeof insn_needs);
/* Count each reload once in every class
containing the reload's own class. */
@ -3178,7 +3178,7 @@ eliminate_regs (x, mem_mode, insn)
if (new != XEXP (x, i) && ! copied)
{
rtx new_x = rtx_alloc (code);
bcopy ((char *) x, (char *) new_x,
copy_memory ((char *) x, (char *) new_x,
(sizeof (*new_x) - sizeof (new_x->fld)
+ sizeof (new_x->fld[0]) * GET_RTX_LENGTH (code)));
x = new_x;
@ -3199,7 +3199,7 @@ eliminate_regs (x, mem_mode, insn)
if (! copied)
{
rtx new_x = rtx_alloc (code);
bcopy ((char *) x, (char *) new_x,
copy_memory ((char *) x, (char *) new_x,
(sizeof (*new_x) - sizeof (new_x->fld)
+ (sizeof (new_x->fld[0])
* GET_RTX_LENGTH (code))));
@ -3576,7 +3576,7 @@ static void
set_initial_label_offsets ()
{
rtx x;
bzero ((char *) &offsets_known_at[get_first_label_num ()], num_labels);
zero_memory ((char *) &offsets_known_at[get_first_label_num ()], num_labels);
for (x = forced_labels; x; x = XEXP (x, 1))
if (XEXP (x, 0))
@ -3700,7 +3700,7 @@ init_elim_table ()
{
reg_eliminate = (struct elim_table *)
xmalloc(sizeof(struct elim_table) * NUM_ELIMINABLE_REGS);
bzero ((PTR) reg_eliminate,
zero_memory ((PTR) reg_eliminate,
sizeof(struct elim_table) * NUM_ELIMINABLE_REGS);
}
@ -3853,7 +3853,7 @@ finish_spills (global, dumpfile)
/* Retry global register allocation if possible. */
if (global)
{
bzero ((char *) pseudo_forbidden_regs, max_regno * sizeof (HARD_REG_SET));
zero_memory ((char *) pseudo_forbidden_regs, 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. */
@ -4193,10 +4193,10 @@ 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);
zero_memory ((char *) spill_reg_rtx, sizeof spill_reg_rtx);
zero_memory ((char *) spill_reg_store, sizeof spill_reg_store);
reg_last_reload_reg = (rtx *) alloca (max_regno * sizeof (rtx));
bzero ((char *) reg_last_reload_reg, max_regno * sizeof (rtx));
zero_memory ((char *) reg_last_reload_reg, max_regno * sizeof (rtx));
reg_has_output_reload = (char *) alloca (max_regno);
CLEAR_HARD_REG_SET (reg_reloaded_valid);
@ -4256,7 +4256,7 @@ reload_as_needed (live_known)
rtx's for those pseudo regs. */
else
{
bzero (reg_has_output_reload, max_regno);
zero_memory (reg_has_output_reload, max_regno);
CLEAR_HARD_REG_SET (reg_is_output_reload);
find_reloads (insn, 1, spill_indirect_levels, live_known,
@ -5612,9 +5612,9 @@ choose_reload_regs (chain)
HARD_REG_SET save_reload_reg_used_in_other_addr;
HARD_REG_SET save_reload_reg_used_at_all;
bzero (reload_inherited, MAX_RELOADS);
bzero ((char *) reload_inheritance_insn, MAX_RELOADS * sizeof (rtx));
bzero ((char *) reload_override_in, MAX_RELOADS * sizeof (rtx));
zero_memory (reload_inherited, MAX_RELOADS);
zero_memory ((char *) reload_inheritance_insn, MAX_RELOADS * sizeof (rtx));
zero_memory ((char *) reload_override_in, MAX_RELOADS * sizeof (rtx));
CLEAR_HARD_REG_SET (reload_reg_used);
CLEAR_HARD_REG_SET (reload_reg_used_at_all);
@ -5705,15 +5705,15 @@ choose_reload_regs (chain)
if (n_reloads > 1)
qsort (reload_order, n_reloads, sizeof (short), reload_reg_class_lower);
bcopy ((char *) reload_reg_rtx, (char *) save_reload_reg_rtx,
copy_memory ((char *) reload_reg_rtx, (char *) save_reload_reg_rtx,
sizeof reload_reg_rtx);
bcopy (reload_inherited, save_reload_inherited, sizeof reload_inherited);
bcopy ((char *) reload_inheritance_insn,
copy_memory (reload_inherited, save_reload_inherited, sizeof reload_inherited);
copy_memory ((char *) reload_inheritance_insn,
(char *) save_reload_inheritance_insn,
sizeof reload_inheritance_insn);
bcopy ((char *) reload_override_in, (char *) save_reload_override_in,
copy_memory ((char *) reload_override_in, (char *) save_reload_override_in,
sizeof reload_override_in);
bcopy ((char *) reload_spill_index, (char *) save_reload_spill_index,
copy_memory ((char *) reload_spill_index, (char *) save_reload_spill_index,
sizeof reload_spill_index);
COPY_HARD_REG_SET (save_reload_reg_used, reload_reg_used);
COPY_HARD_REG_SET (save_reload_reg_used_at_all, reload_reg_used_at_all);
@ -6181,16 +6181,16 @@ choose_reload_regs (chain)
/* Loop around and try without any inheritance. */
/* First undo everything done by the failed attempt
to allocate with inheritance. */
bcopy ((char *) save_reload_reg_rtx, (char *) reload_reg_rtx,
copy_memory ((char *) save_reload_reg_rtx, (char *) reload_reg_rtx,
sizeof reload_reg_rtx);
bcopy ((char *) save_reload_inherited, (char *) reload_inherited,
copy_memory ((char *) save_reload_inherited, (char *) reload_inherited,
sizeof reload_inherited);
bcopy ((char *) save_reload_inheritance_insn,
copy_memory ((char *) save_reload_inheritance_insn,
(char *) reload_inheritance_insn,
sizeof reload_inheritance_insn);
bcopy ((char *) save_reload_override_in, (char *) reload_override_in,
copy_memory ((char *) save_reload_override_in, (char *) reload_override_in,
sizeof reload_override_in);
bcopy ((char *) save_reload_spill_index, (char *) reload_spill_index,
copy_memory ((char *) save_reload_spill_index, (char *) reload_spill_index,
sizeof reload_spill_index);
COPY_HARD_REG_SET (reload_reg_used, save_reload_reg_used);
COPY_HARD_REG_SET (reload_reg_used_at_all, save_reload_reg_used_at_all);
@ -8664,7 +8664,7 @@ reload_cse_regs_1 (first)
init_alias_analysis ();
reg_values = (rtx *) alloca (FIRST_PSEUDO_REGISTER * sizeof (rtx));
bzero ((char *)reg_values, FIRST_PSEUDO_REGISTER * sizeof (rtx));
zero_memory ((char *)reg_values, FIRST_PSEUDO_REGISTER * sizeof (rtx));
/* Create our EXPR_LIST structures on reload_obstack, so that we can
free them when we are done. */
@ -9105,8 +9105,8 @@ reload_cse_simplify_operands (insn)
alternative_reject = (int *) alloca (recog_n_alternatives * sizeof (int));
alternative_nregs = (int *) alloca (recog_n_alternatives * sizeof (int));
alternative_order = (int *) alloca (recog_n_alternatives * sizeof (int));
bzero ((char *)alternative_reject, recog_n_alternatives * sizeof (int));
bzero ((char *)alternative_nregs, recog_n_alternatives * sizeof (int));
zero_memory ((char *)alternative_reject, recog_n_alternatives * sizeof (int));
zero_memory ((char *)alternative_nregs, recog_n_alternatives * sizeof (int));
for (i = 0; i < recog_n_operands; i++)
{

4
gcc/reorg.c
View File

@ -3556,8 +3556,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);
zero_memory ((char *) num_insns_needing_delays, sizeof num_insns_needing_delays);
zero_memory ((char *) num_filled_delays, sizeof num_filled_delays);
/* Now do the delay slot filling. Try everything twice in case earlier
changes make more slots fillable. */

4
gcc/resource.c
View File

@ -1146,11 +1146,11 @@ init_resource_info (epilogue_insn)
target_hash_table
= (struct target_info **) xmalloc ((TARGET_HASH_PRIME
* sizeof (struct target_info *)));
bzero ((char *) target_hash_table,
zero_memory ((char *) target_hash_table,
TARGET_HASH_PRIME * sizeof (struct target_info *));
bb_ticks = (int *) xmalloc (n_basic_blocks * sizeof (int));
bzero ((char *) bb_ticks, n_basic_blocks * sizeof (int));
zero_memory ((char *) bb_ticks, n_basic_blocks * sizeof (int));
}
/* Free up the resources allcated to mark_target_live_regs (). This

4
gcc/sbitmap.c
View File

@ -96,7 +96,7 @@ void
sbitmap_copy (dst, src)
sbitmap dst, src;
{
bcopy (src->elms, dst->elms, sizeof (SBITMAP_ELT_TYPE) * dst->size);
copy_memory (src->elms, dst->elms, sizeof (SBITMAP_ELT_TYPE) * dst->size);
}
/* Zero all elements in a bitmap. */
@ -105,7 +105,7 @@ void
sbitmap_zero (bmap)
sbitmap bmap;
{
bzero ((char *) bmap->elms, bmap->bytes);
zero_memory ((char *) bmap->elms, bmap->bytes);
}
/* Set to ones all elements in a bitmap. */

34
gcc/sched.c
View File

@ -637,9 +637,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));
zero_memory ((char *) unit_last_insn, sizeof (unit_last_insn));
zero_memory ((char *) unit_tick, sizeof (unit_tick));
zero_memory ((char *) unit_n_insns, sizeof (unit_n_insns));
}
/* Record an insn as one that will use the units encoded by UNIT. */
@ -2633,9 +2633,9 @@ schedule_block (b, file)
i = max_reg_num ();
reg_last_uses = (rtx *) alloca (i * sizeof (rtx));
bzero ((char *) reg_last_uses, i * sizeof (rtx));
zero_memory ((char *) reg_last_uses, i * sizeof (rtx));
reg_last_sets = (rtx *) alloca (i * sizeof (rtx));
bzero ((char *) reg_last_sets, i * sizeof (rtx));
zero_memory ((char *) reg_last_sets, i * sizeof (rtx));
reg_pending_sets = ALLOCA_REG_SET ();
CLEAR_REG_SET (reg_pending_sets);
reg_pending_sets_all = 0;
@ -3132,7 +3132,7 @@ schedule_block (b, file)
/* Q_SIZE will always be zero here. */
q_ptr = 0; clock = 0;
bzero ((char *) insn_queue, sizeof (insn_queue));
zero_memory ((char *) insn_queue, sizeof (insn_queue));
/* Now, perform list scheduling. */
@ -4258,8 +4258,8 @@ schedule_insns (dump_file)
sched_reg_live_length = (int *) alloca (max_regno * sizeof (int));
bb_dead_regs = ALLOCA_REG_SET ();
bb_live_regs = ALLOCA_REG_SET ();
bzero ((char *) sched_reg_n_calls_crossed, max_regno * sizeof (int));
bzero ((char *) sched_reg_live_length, max_regno * sizeof (int));
zero_memory ((char *) sched_reg_n_calls_crossed, max_regno * sizeof (int));
zero_memory ((char *) sched_reg_live_length, max_regno * sizeof (int));
}
else
{
@ -4275,9 +4275,9 @@ schedule_insns (dump_file)
rtx line;
line_note = (rtx *) xmalloc (max_uid * sizeof (rtx));
bzero ((char *) line_note, max_uid * sizeof (rtx));
zero_memory ((char *) line_note, max_uid * sizeof (rtx));
line_note_head = (rtx *) alloca (n_basic_blocks * sizeof (rtx));
bzero ((char *) line_note_head, n_basic_blocks * sizeof (rtx));
zero_memory ((char *) line_note_head, n_basic_blocks * sizeof (rtx));
/* Determine the line-number at the start of each basic block.
This must be computed and saved now, because after a basic block's
@ -4293,13 +4293,13 @@ schedule_insns (dump_file)
}
}
bzero ((char *) insn_luid, max_uid * sizeof (int));
bzero ((char *) insn_priority, max_uid * sizeof (int));
bzero ((char *) insn_tick, max_uid * sizeof (int));
bzero ((char *) insn_costs, max_uid * sizeof (short));
bzero ((char *) insn_units, max_uid * sizeof (short));
bzero ((char *) insn_blockage, max_uid * sizeof (unsigned int));
bzero ((char *) insn_ref_count, max_uid * sizeof (int));
zero_memory ((char *) insn_luid, max_uid * sizeof (int));
zero_memory ((char *) insn_priority, max_uid * sizeof (int));
zero_memory ((char *) insn_tick, max_uid * sizeof (int));
zero_memory ((char *) insn_costs, max_uid * sizeof (short));
zero_memory ((char *) insn_units, max_uid * sizeof (short));
zero_memory ((char *) insn_blockage, max_uid * sizeof (unsigned int));
zero_memory ((char *) insn_ref_count, max_uid * sizeof (int));
/* Schedule each basic block, block by block. */

8
gcc/stmt.c
View File

@ -1283,7 +1283,7 @@ expand_asm_operands (string, outputs, inputs, clobbers, vol, filename, line)
if (p != constraint)
{
j = *p;
bcopy (constraint, constraint+1, p-constraint);
copy_memory (constraint, constraint+1, p-constraint);
*constraint = j;
warning ("output constraint `%c' for operand %d is not at the beginning", j, i);
@ -4784,7 +4784,7 @@ check_for_full_enumeration_handling (type)
{
long i;
tree v = TYPE_VALUES (type);
bzero (cases_seen, bytes_needed);
zero_memory (cases_seen, bytes_needed);
/* The time complexity of this code is normally O(N), where
N being the number of members in the enumerated type.
@ -5205,7 +5205,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));
zero_memory ((char *) labelvec, ncases * sizeof (rtx));
for (n = thiscase->data.case_stmt.case_list; n; n = n->right)
{
@ -5349,7 +5349,7 @@ estimate_case_costs (node)
if (cost_table == NULL)
{
cost_table = ((short *) xmalloc (129 * sizeof (short))) + 1;
bzero ((char *) (cost_table - 1), 129 * sizeof (short));
zero_memory ((char *) (cost_table - 1), 129 * sizeof (short));
for (i = 0; i < 128; i++)
{

20
gcc/stupid.c
View File

@ -184,7 +184,7 @@ stupid_life_analysis (f, nregs, file)
current_function_has_computed_jump = 0;
bzero (regs_ever_live, sizeof regs_ever_live);
zero_memory (regs_ever_live, sizeof regs_ever_live);
regs_live = (char *) xmalloc (nregs);
@ -220,25 +220,25 @@ stupid_life_analysis (f, nregs, file)
/* Allocate tables to record info about regs. */
reg_where_dead = (int *) xmalloc (nregs * sizeof (int));
bzero ((char *) reg_where_dead, nregs * sizeof (int));
zero_memory ((char *) reg_where_dead, nregs * sizeof (int));
reg_where_born_exact = (int *) xmalloc (nregs * sizeof (int));
bzero ((char *) reg_where_born_exact, nregs * sizeof (int));
zero_memory ((char *) reg_where_born_exact, nregs * sizeof (int));
reg_where_born_clobber = (int *) xmalloc (nregs * sizeof (int));
bzero ((char *) reg_where_born_clobber, nregs * sizeof (int));
zero_memory ((char *) reg_where_born_clobber, nregs * sizeof (int));
reg_where_dead_chain = (struct insn_chain **) xmalloc (nregs * sizeof (struct insn_chain *));
bzero ((char *) reg_where_dead_chain, nregs * sizeof (struct insn_chain *));
zero_memory ((char *) reg_where_dead_chain, nregs * sizeof (struct insn_chain *));
reg_order = (int *) xmalloc (nregs * sizeof (int));
bzero ((char *) reg_order, nregs * sizeof (int));
zero_memory ((char *) reg_order, nregs * sizeof (int));
regs_change_size = (char *) xmalloc (nregs * sizeof (char));
bzero ((char *) regs_change_size, nregs * sizeof (char));
zero_memory ((char *) regs_change_size, nregs * sizeof (char));
regs_crosses_setjmp = (char *) xmalloc (nregs * sizeof (char));
bzero ((char *) regs_crosses_setjmp, nregs * sizeof (char));
zero_memory ((char *) regs_crosses_setjmp, nregs * sizeof (char));
/* Allocate the reg_renumber array */
allocate_reg_info (max_regno, FALSE, TRUE);
@ -248,7 +248,7 @@ stupid_life_analysis (f, nregs, file)
after_insn_hard_regs
= (HARD_REG_SET *) xmalloc (max_suid * sizeof (HARD_REG_SET));
bzero ((char *) after_insn_hard_regs, max_suid * sizeof (HARD_REG_SET));
zero_memory ((char *) after_insn_hard_regs, max_suid * sizeof (HARD_REG_SET));
/* Allocate and zero out many data structures
that will record the data from lifetime analysis. */
@ -258,7 +258,7 @@ stupid_life_analysis (f, nregs, file)
for (i = 0; i < max_regno; i++)
REG_N_DEATHS (i) = 1;
bzero (regs_live, nregs);
zero_memory (regs_live, nregs);
/* Find where each pseudo register is born and dies,
by scanning all insns from the end to the start

65
gcc/system.h
View File

@ -118,18 +118,7 @@ Boston, MA 02111-1307, USA. */
extern int errno;
#endif
#ifdef STRING_WITH_STRINGS
# include <string.h>
# include <strings.h>
#else
# ifdef HAVE_STRING_H
# include <string.h>
# else
# ifdef HAVE_STRINGS_H
# include <strings.h>
# endif
# endif
#endif
#include <string.h>
#ifdef HAVE_STDLIB_H
# include <stdlib.h>
@ -212,57 +201,9 @@ extern int errno;
#define WEXITSTATUS(S) (((S) & 0xff00) >> 8)
#endif
#define copy_memory(src,dst,len) memcpy((dst),(src),(len))
#ifndef bcopy
# ifdef HAVE_BCOPY
# ifdef NEED_DECLARATION_BCOPY
extern void bcopy ();
# endif
# else /* ! HAVE_BCOPY */
# define bcopy(src,dst,len) memcpy ((dst),(src),(len))
# endif
#endif
#ifndef bcmp
# ifdef HAVE_BCMP
# ifdef NEED_DECLARATION_BCMP
extern int bcmp ();
# endif
# else /* ! HAVE_BCMP */
# define bcmp(left,right,len) memcmp ((left),(right),(len))
# endif
#endif
#ifndef bzero
# ifdef HAVE_BZERO
# ifdef NEED_DECLARATION_BZERO
extern void bzero ();
# endif
# else /* ! HAVE_BZERO */
# define bzero(dst,len) memset ((dst),0,(len))
# endif
#endif
#ifndef index
# ifdef HAVE_INDEX
# ifdef NEED_DECLARATION_INDEX
extern char *index ();
# endif
# else /* ! HAVE_INDEX */
# define index strchr
# endif
#endif
#ifndef rindex
# ifdef HAVE_RINDEX
# ifdef NEED_DECLARATION_RINDEX
extern char *rindex ();
# endif
# else /* ! HAVE_RINDEX */
# define rindex strrchr
# endif
#endif
#define zero_memory(dst,len) memset((dst),0,(len))
#ifdef NEED_DECLARATION_ATOF
extern double atof ();

2
gcc/testsuite/gcc.c-torture/unsorted/bcopy.c
View File

@ -60,5 +60,5 @@ main ()
int i;
for (i = 1; i < 67108864 / BYTES; i++)
bcopy (s, d, BYTES);
copy_memory (s, d, BYTES);
}

2
gcc/testsuite/gcc.c-torture/unsorted/memtst.c
View File

@ -18,7 +18,7 @@ main ()
{
int a[SIZE];
int i;
bzero (a, SIZE * 4);
zero_memory (a, SIZE * 4);
for (i = 0; i < 100; i++)
{
memtst (a, SIZE);

4
gcc/toplev.c
View File

@ -2199,7 +2199,7 @@ set_float_handler (handler)
{
float_handled = (handler != 0);
if (handler)
bcopy ((char *) handler, (char *) float_handler, sizeof (float_handler));
copy_memory ((char *) handler, (char *) float_handler, sizeof (float_handler));
if (float_handled && ! float_handler_set)
{
@ -2237,7 +2237,7 @@ pop_float_handler (handled, handler)
{
float_handled = handled;
if (handled)
bcopy ((char *) handler, (char *) float_handler, sizeof (float_handler));
copy_memory ((char *) handler, (char *) float_handler, sizeof (float_handler));
}
/* Handler for SIGPIPE. */

16
gcc/tree.c
View File

@ -297,7 +297,7 @@ init_obstacks ()
rtl_obstack = saveable_obstack = &permanent_obstack;
/* Init the hash table of identifiers. */
bzero ((char *) hash_table, sizeof hash_table);
zero_memory ((char *) hash_table, sizeof hash_table);
}
void
@ -713,7 +713,7 @@ perm_calloc (nelem, size)
long size;
{
char *rval = (char *) obstack_alloc (&permanent_obstack, nelem * size);
bzero (rval, nelem * size);
zero_memory (rval, nelem * size);
return rval;
}
@ -1070,7 +1070,7 @@ make_node (code)
}
t = (tree) obstack_alloc (obstack, length);
bzero (t, length);
zero_memory (t, length);
#ifdef GATHER_STATISTICS
tree_node_counts[(int)kind]++;
@ -1268,7 +1268,7 @@ get_identifier (text)
for (idp = hash_table[hi]; idp; idp = TREE_CHAIN (idp))
if (IDENTIFIER_LENGTH (idp) == len
&& IDENTIFIER_POINTER (idp)[0] == text[0]
&& !bcmp (IDENTIFIER_POINTER (idp), text, len))
&& !memcmp (IDENTIFIER_POINTER (idp), text, len))
return idp; /* <-- return if found */
/* Not found; optionally warn about a similar identifier */
@ -1331,7 +1331,7 @@ maybe_get_identifier (text)
for (idp = hash_table[hi]; idp; idp = TREE_CHAIN (idp))
if (IDENTIFIER_LENGTH (idp) == len
&& IDENTIFIER_POINTER (idp)[0] == text[0]
&& !bcmp (IDENTIFIER_POINTER (idp), text, len))
&& !memcmp (IDENTIFIER_POINTER (idp), text, len))
return idp; /* <-- return if found */
return NULL_TREE;
@ -1551,7 +1551,7 @@ make_tree_vec (len)
#endif
t = (tree) obstack_alloc (obstack, length);
bzero (t, length);
zero_memory (t, length);
TREE_SET_CODE (t, TREE_VEC);
TREE_VEC_LENGTH (t) = len;
@ -3058,7 +3058,7 @@ build1 (code, type, node)
length = sizeof (struct tree_exp);
t = (tree) obstack_alloc (obstack, length);
bzero (t, length);
zero_memory (t, length);
#ifdef GATHER_STATISTICS
tree_node_counts[(int)kind]++;
@ -3968,7 +3968,7 @@ simple_cst_equal (t1, t2)
case STRING_CST:
return TREE_STRING_LENGTH (t1) == TREE_STRING_LENGTH (t2)
&& !bcmp (TREE_STRING_POINTER (t1), TREE_STRING_POINTER (t2),
&& !memcmp (TREE_STRING_POINTER (t1), TREE_STRING_POINTER (t2),
TREE_STRING_LENGTH (t1));
case CONSTRUCTOR:

24
gcc/unroll.c
View File

@ -693,7 +693,7 @@ unroll_loop (loop_end, insn_count, loop_start, end_insert_before,
map->label_map = (rtx *) alloca (max_labelno * sizeof (rtx));
local_label = (char *) alloca (max_labelno);
bzero (local_label, max_labelno);
zero_memory (local_label, max_labelno);
}
else
map->label_map = 0;
@ -768,16 +768,16 @@ unroll_loop (loop_end, insn_count, loop_start, end_insert_before,
to access the splittable_regs[] and addr_combined_regs[] arrays. */
splittable_regs = (rtx *) alloca (maxregnum * sizeof (rtx));
bzero ((char *) splittable_regs, maxregnum * sizeof (rtx));
zero_memory ((char *) splittable_regs, maxregnum * sizeof (rtx));
derived_regs = alloca (maxregnum);
bzero (derived_regs, maxregnum);
zero_memory (derived_regs, maxregnum);
splittable_regs_updates = (int *) alloca (maxregnum * sizeof (int));
bzero ((char *) splittable_regs_updates, maxregnum * sizeof (int));
zero_memory ((char *) splittable_regs_updates, maxregnum * sizeof (int));
addr_combined_regs
= (struct induction **) alloca (maxregnum * sizeof (struct induction *));
bzero ((char *) addr_combined_regs, maxregnum * sizeof (struct induction *));
zero_memory ((char *) addr_combined_regs, maxregnum * sizeof (struct induction *));
local_regno = (char *) alloca (maxregnum);
bzero (local_regno, maxregnum);
zero_memory (local_regno, maxregnum);
/* Mark all local registers, i.e. the ones which are referenced only
inside the loop. */
@ -1048,9 +1048,9 @@ unroll_loop (loop_end, insn_count, loop_start, end_insert_before,
emit_label_after (labels[unroll_number - i],
PREV_INSN (loop_start));
bzero ((char *) map->insn_map, max_insnno * sizeof (rtx));
bzero ((char *) map->const_equiv_map, maxregnum * sizeof (rtx));
bzero ((char *) map->const_age_map,
zero_memory ((char *) map->insn_map, max_insnno * sizeof (rtx));
zero_memory ((char *) map->const_equiv_map, maxregnum * sizeof (rtx));
zero_memory ((char *) map->const_age_map,
maxregnum * sizeof (unsigned));
map->const_age = 0;
@ -1205,9 +1205,9 @@ unroll_loop (loop_end, insn_count, loop_start, end_insert_before,
for (i = 0; i < unroll_number; i++)
{
bzero ((char *) map->insn_map, max_insnno * sizeof (rtx));
bzero ((char *) map->const_equiv_map, new_maxregnum * sizeof (rtx));
bzero ((char *) map->const_age_map, new_maxregnum * sizeof (unsigned));
zero_memory ((char *) map->insn_map, max_insnno * sizeof (rtx));
zero_memory ((char *) map->const_equiv_map, new_maxregnum * sizeof (rtx));
zero_memory ((char *) map->const_age_map, new_maxregnum * sizeof (unsigned));
map->const_age = 0;
for (j = 0; j < max_labelno; j++)

24
gcc/unroll_991002.c
View File

@ -692,7 +692,7 @@ unroll_loop (loop_end, insn_count, loop_start, end_insert_before,
map->label_map = (rtx *) alloca (max_labelno * sizeof (rtx));
local_label = (char *) alloca (max_labelno);
bzero (local_label, max_labelno);
zero_memory (local_label, max_labelno);
}
else
map->label_map = 0;
@ -764,16 +764,16 @@ unroll_loop (loop_end, insn_count, loop_start, end_insert_before,
to access the splittable_regs[] and addr_combined_regs[] arrays. */
splittable_regs = (rtx *) alloca (maxregnum * sizeof (rtx));
bzero ((char *) splittable_regs, maxregnum * sizeof (rtx));
zero_memory ((char *) splittable_regs, maxregnum * sizeof (rtx));
derived_regs = alloca (maxregnum);
bzero (derived_regs, maxregnum);
zero_memory (derived_regs, maxregnum);
splittable_regs_updates = (int *) alloca (maxregnum * sizeof (int));
bzero ((char *) splittable_regs_updates, maxregnum * sizeof (int));
zero_memory ((char *) splittable_regs_updates, maxregnum * sizeof (int));
addr_combined_regs
= (struct induction **) alloca (maxregnum * sizeof (struct induction *));
bzero ((char *) addr_combined_regs, maxregnum * sizeof (struct induction *));
zero_memory ((char *) addr_combined_regs, maxregnum * sizeof (struct induction *));
local_regno = (char *) alloca (maxregnum);
bzero (local_regno, maxregnum);
zero_memory (local_regno, maxregnum);
/* Mark all local registers, i.e. the ones which are referenced only
inside the loop. */
@ -1044,9 +1044,9 @@ unroll_loop (loop_end, insn_count, loop_start, end_insert_before,
emit_label_after (labels[unroll_number - i],
PREV_INSN (loop_start));
bzero ((char *) map->insn_map, max_insnno * sizeof (rtx));
bzero ((char *) map->const_equiv_map, maxregnum * sizeof (rtx));
bzero ((char *) map->const_age_map,
zero_memory ((char *) map->insn_map, max_insnno * sizeof (rtx));
zero_memory ((char *) map->const_equiv_map, maxregnum * sizeof (rtx));
zero_memory ((char *) map->const_age_map,
maxregnum * sizeof (unsigned));
map->const_age = 0;
@ -1201,9 +1201,9 @@ unroll_loop (loop_end, insn_count, loop_start, end_insert_before,
for (i = 0; i < unroll_number; i++)
{
bzero ((char *) map->insn_map, max_insnno * sizeof (rtx));
bzero ((char *) map->const_equiv_map, new_maxregnum * sizeof (rtx));
bzero ((char *) map->const_age_map, new_maxregnum * sizeof (unsigned));
zero_memory ((char *) map->insn_map, max_insnno * sizeof (rtx));
zero_memory ((char *) map->const_equiv_map, new_maxregnum * sizeof (rtx));
zero_memory ((char *) map->const_age_map, new_maxregnum * sizeof (unsigned));
map->const_age = 0;
for (j = 0; j < max_labelno; j++)

34
gcc/varasm.c
View File

@ -1575,7 +1575,7 @@ assemble_name (file, name)
STRIP_NAME_ENCODING (real_name, name);
if (flag_prefix_function_name
&& ! bcmp (real_name, CHKR_PREFIX, CHKR_PREFIX_SIZE))
&& ! memcmp (real_name, CHKR_PREFIX, CHKR_PREFIX_SIZE))
real_name = real_name + CHKR_PREFIX_SIZE;
id = maybe_get_identifier (real_name);
@ -1777,7 +1777,7 @@ assemble_real (d, mode)
{
error ("floating point trap outputting a constant");
#ifdef REAL_IS_NOT_DOUBLE
bzero ((char *) &d, sizeof d);
zero_memory ((char *) &d, sizeof d);
d = dconst0;
#else
d = 0;
@ -1992,7 +1992,7 @@ immed_real_const_1 (d, mode)
If one is found, return it. */
for (r = const_double_chain; r; r = CONST_DOUBLE_CHAIN (r))
if (! bcmp ((char *) &CONST_DOUBLE_LOW (r), (char *) &u, sizeof u)
if (! memcmp ((char *) &CONST_DOUBLE_LOW (r), (char *) &u, sizeof u)
&& GET_MODE (r) == mode)
return r;
@ -2008,7 +2008,7 @@ immed_real_const_1 (d, mode)
rtl_in_saveable_obstack ();
r = rtx_alloc (CONST_DOUBLE);
PUT_MODE (r, mode);
bcopy ((char *) &u, (char *) &CONST_DOUBLE_LOW (r), sizeof u);
copy_memory ((char *) &u, (char *) &CONST_DOUBLE_LOW (r), sizeof u);
pop_obstacks ();
/* Don't touch const_double_chain in nested function; see force_const_mem.
@ -2334,7 +2334,7 @@ compare_constant_1 (exp, p)
strp = TREE_STRING_POINTER (exp);
len = TREE_STRING_LENGTH (exp);
if (bcmp ((char *) &TREE_STRING_LENGTH (exp), p,
if (memcmp ((char *) &TREE_STRING_LENGTH (exp), p,
sizeof TREE_STRING_LENGTH (exp)))
return 0;
@ -2355,7 +2355,7 @@ compare_constant_1 (exp, p)
strp = (char *) alloca (len);
get_set_constructor_bytes (exp, (unsigned char *) strp, len);
if (bcmp ((char *) &xlen, p, sizeof xlen))
if (memcmp ((char *) &xlen, p, sizeof xlen))
return 0;
p += sizeof xlen;
@ -2372,7 +2372,7 @@ compare_constant_1 (exp, p)
if (TREE_PURPOSE (link))
have_purpose = 1;
if (bcmp ((char *) &length, p, sizeof length))
if (memcmp ((char *) &length, p, sizeof length))
return 0;
p += sizeof length;
@ -2386,12 +2386,12 @@ compare_constant_1 (exp, p)
else
type = 0;
if (bcmp ((char *) &type, p, sizeof type))
if (memcmp ((char *) &type, p, sizeof type))
return 0;
p += sizeof type;
if (bcmp ((char *) &have_purpose, p, sizeof have_purpose))
if (memcmp ((char *) &have_purpose, p, sizeof have_purpose))
return 0;
p += sizeof have_purpose;
@ -2401,7 +2401,7 @@ compare_constant_1 (exp, p)
{
HOST_WIDE_INT size = int_size_in_bytes (TREE_TYPE (exp));
if (bcmp ((char *) &size, p, sizeof size))
if (memcmp ((char *) &size, p, sizeof size))
return 0;
p += sizeof size;
@ -2418,7 +2418,7 @@ compare_constant_1 (exp, p)
{
tree zero = 0;
if (bcmp ((char *) &zero, p, sizeof zero))
if (memcmp ((char *) &zero, p, sizeof zero))
return 0;
p += sizeof zero;
@ -2427,7 +2427,7 @@ compare_constant_1 (exp, p)
if (TREE_PURPOSE (link)
&& TREE_CODE (TREE_PURPOSE (link)) == FIELD_DECL)
{
if (bcmp ((char *) &TREE_PURPOSE (link), p,
if (memcmp ((char *) &TREE_PURPOSE (link), p,
sizeof TREE_PURPOSE (link)))
return 0;
@ -2442,7 +2442,7 @@ compare_constant_1 (exp, p)
{
int zero = 0;
if (bcmp ((char *) &zero, p, sizeof zero))
if (memcmp ((char *) &zero, p, sizeof zero))
return 0;
p += sizeof zero;
@ -3044,9 +3044,9 @@ init_const_rtx_hash_table ()
const_rtx_sym_hash_table
= ((struct pool_sym **)
oballoc (MAX_RTX_HASH_TABLE * sizeof (struct pool_sym *)));
bzero ((char *) const_rtx_hash_table,
zero_memory ((char *) const_rtx_hash_table,
MAX_RTX_HASH_TABLE * sizeof (struct constant_descriptor *));
bzero ((char *) const_rtx_sym_hash_table,
zero_memory ((char *) const_rtx_sym_hash_table,
MAX_RTX_HASH_TABLE * sizeof (struct pool_sym *));
first_pool = last_pool = 0;
@ -3131,7 +3131,7 @@ decode_rtx_const (mode, x, value)
if (GET_MODE (x) != VOIDmode)
{
value->mode = GET_MODE (x);
bcopy ((char *) &CONST_DOUBLE_LOW (x),
copy_memory ((char *) &CONST_DOUBLE_LOW (x),
(char *) &value->un.du, sizeof value->un.du);
}
else
@ -3556,7 +3556,7 @@ output_constant_pool (fnname, fndecl)
if (GET_CODE (x) != CONST_DOUBLE)
abort ();
bcopy ((char *) &CONST_DOUBLE_LOW (x), (char *) &u, sizeof u);
copy_memory ((char *) &CONST_DOUBLE_LOW (x), (char *) &u, sizeof u);
assemble_real (u.d, pool->mode);
break;

2
gcc/varray.c
View File

@ -63,7 +63,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);
zero_memory (&va->data.c[old_data_size], data_size - old_data_size);
}
return va;