if (i % 8 != 0)
putc ('\n', file);
- bcopy (seg->data + i, &offset, sizeof (int));
+ bcopy (seg->data + i, (char *) &offset, sizeof (int));
i += sizeof (int) - 1;
BC_WRITE_RELOC_ENTRY (segreloc, file, offset);
if (ref->label->defined)
{
addr = ref->label->offset;
- bcopy (&addr, bytecode->data + ref->offset, sizeof addr);
+ bcopy ((char *) &addr, bytecode->data + ref->offset, sizeof addr);
}
/* Free the chains of labelrefs and labeldefs. */
/* Make a vector to hold all the information about each arg. */
args = (struct arg_data *) alloca (num_actuals * sizeof (struct arg_data));
- bzero (args, num_actuals * sizeof (struct arg_data));
+ bzero ((char *) args, num_actuals * sizeof (struct arg_data));
args_size.constant = 0;
args_size.var = 0;
cplusplus = 0;
cplusplus_comments = 0;
- bzero (pend_files, argc * sizeof (char *));
- bzero (pend_defs, argc * sizeof (char *));
- bzero (pend_undefs, argc * sizeof (char *));
- bzero (pend_assertions, argc * sizeof (char *));
- bzero (pend_includes, argc * sizeof (char *));
+ bzero ((char *) pend_files, argc * sizeof (char *));
+ bzero ((char *) pend_defs, argc * sizeof (char *));
+ bzero ((char *) pend_undefs, argc * sizeof (char *));
+ bzero ((char *) pend_assertions, argc * sizeof (char *));
+ bzero ((char *) pend_includes, argc * sizeof (char *));
/* Process switches and find input file name. */
endp++;
}
/* Put the usual defaults back in at the end. */
- bcopy (include_defaults_array, &include_defaults[num_dirs],
+ bcopy ((char *) include_defaults_array,
+ (char *) &include_defaults[num_dirs],
sizeof (include_defaults_array));
}
}
continue;
}
len = sptr - fptr - 2;
+
+ /* BSD doc says bcopy () works right for overlapping strings. In ANSI
+ C, this will be memmove (). */
if (bptr != fptr && len > 0)
- bcopy (fptr, bptr, len); /* BSD doc says bcopy () works right
- for overlapping strings. In ANSI
- C, this will be memmove (). */
+ bcopy ((char *) fptr, (char *) bptr, len);
+
bptr += len;
*bptr++ = c;
fptr = ++sptr;
}
len = buf->length - (fptr - buf->buf);
if (bptr != fptr && len > 0)
- bcopy (fptr, bptr, len);
+ bcopy ((char *) fptr, (char *) bptr, len);
buf->length -= fptr - bptr;
buf->buf[buf->length] = '\0';
if (warn_trigraphs && fptr != bptr)
if (*ibp == '(') {
ip->bufp = ibp;
skip_paren_group (ip);
- bcopy (ibp, obp, ip->bufp - ibp);
+ bcopy ((char *) ibp, (char *) obp, ip->bufp - ibp);
obp += ip->bufp - ibp;
ibp = ip->bufp;
}
while (ibp < limit) {
if (ibp[-1] != '\\' && *ibp == '\n') {
if (put_out_comments) {
- bcopy (before_bp, obp, ibp - before_bp);
+ bcopy ((char *) before_bp, (char *) obp, ibp - before_bp);
obp += ibp - before_bp;
}
break;
if (lintcmd != NULL) {
/* I believe it is always safe to emit this newline: */
obp[-1] = '\n';
- bcopy ("#pragma lint ", obp, 13);
+ bcopy ("#pragma lint ", (char *) obp, 13);
obp += 13;
- bcopy (lintcmd, obp, cmdlen);
+ bcopy (lintcmd, (char *) obp, cmdlen);
obp += cmdlen;
if (arglen != 0) {
*(obp++) = ' ';
- bcopy (argbp, obp, arglen);
+ bcopy (argbp, (char *) obp, arglen);
obp += arglen;
}
else {
ibp++;
if (put_out_comments) {
- bcopy (before_bp, obp, ibp - before_bp);
+ bcopy ((char *) before_bp, (char *) obp, ibp - before_bp);
obp += ibp - before_bp;
}
}
/* Output arguments. */
len = (bp - buf);
check_expand (op, len);
- bcopy (buf, op->bufp, len);
+ bcopy (buf, (char *) op->bufp, len);
op->bufp += len;
/* Take account of any (escaped) newlines just output. */
while (--len >= 0)
/* Output directive name. */
check_expand (op, kt->length + 1);
*op->bufp++ = '#';
- bcopy (kt->name, op->bufp, kt->length);
+ bcopy (kt->name, (char *) op->bufp, kt->length);
op->bufp += kt->length;
if (kt->pass_thru || dump_macros == dump_definitions) {
/* Output arguments. */
len = (cp - buf);
check_expand (op, len);
- bcopy (buf, op->bufp, len);
+ bcopy (buf, (char *) op->bufp, len);
op->bufp += len;
} else if (kt->type == T_DEFINE && dump_macros == dump_names) {
U_CHAR *xp = buf;
}
len = strlen (buf);
check_expand (op, len);
- bcopy (buf, op->bufp, len);
+ bcopy (buf, (char *) op->bufp, len);
op->bufp += len;
return;
} else {
trybuf = expand_to_temp_buffer (buf, limit, 0, 0);
buf = (U_CHAR *) alloca (trybuf.bufp - trybuf.buf + 1);
- bcopy (trybuf.buf, buf, trybuf.bufp - trybuf.buf);
+ bcopy ((char *) trybuf.buf, (char *) buf, trybuf.bufp - trybuf.buf);
limit = buf + (trybuf.bufp - trybuf.buf);
free (trybuf.buf);
retried++;
struct stat s;
fstat (pcf, &s);
- if (bcmp (&stat_f.st_ino, &s.st_ino, sizeof (s.st_ino))
+ if (bcmp ((char *) &stat_f.st_ino, (char *) &s.st_ino,
+ sizeof (s.st_ino))
|| stat_f.st_dev != s.st_dev)
{
pcfbuf = check_precompiled (pcf, fname, &pcfbuflimit);
}
fp = &instack[indepth + 1];
- bzero (fp, sizeof (FILE_BUF));
+ bzero ((char *) fp, sizeof (FILE_BUF));
fp->nominal_fname = fp->fname = fname;
fp->length = 0;
fp->lineno = 1;
while (i) {
/* Compare the inode and the device.
Supposedly on some systems the inode is not a scalar. */
- if (!bcmp (&i->inode, &sb.st_ino, sizeof (sb.st_ino))
+ if (!bcmp ((char *) &i->inode, (char *) &sb.st_ino, sizeof (sb.st_ino))
&& i->dev == sb.st_dev) {
close (fd);
return -2; /* return found */
i = (struct import_file *)xmalloc (sizeof (struct import_file));
i->name = (char *)xmalloc (strlen (fname)+1);
strcpy (i->name, fname);
- bcopy (&sb.st_ino, &i->inode, sizeof (sb.st_ino));
+ bcopy ((char *) &sb.st_ino, (char *) &i->inode, sizeof (sb.st_ino));
i->dev = sb.st_dev;
i->next = import_hash_table[hashval];
import_hash_table[hashval] = i;
check_expand (op, 1 + keyword_length + (limit - buf));
*op->bufp++ = '#';
- bcopy (keyword->name, op->bufp, keyword_length);
+ bcopy (keyword->name, (char *) op->bufp, keyword_length);
op->bufp += keyword_length;
if (limit != buf && buf[0] != ' ')
*op->bufp++ = ' ';
- bcopy (buf, op->bufp, limit - buf);
+ bcopy ((char *) buf, (char *) op->bufp, limit - buf);
op->bufp += (limit - buf);
#if 0
*op->bufp++ = '\n';
msg = (U_CHAR *) alloca (mdef.symlen + 22);
*msg = '`';
- bcopy (mdef.symnam, msg + 1, mdef.symlen);
+ bcopy ((char *) mdef.symnam, (char *) (msg + 1), mdef.symlen);
strcpy ((char *) (msg + mdef.symlen + 1), "' redefined");
pedwarn (msg);
if (hp->type == T_MACRO)
else if (!is_idstart[*symname]) {
U_CHAR *msg; /* what pain... */
msg = (U_CHAR *) alloca (sym_length + 1);
- bcopy (symname, msg, sym_length);
+ bcopy ((char *) symname, (char *) msg, sym_length);
msg[sym_length] = 0;
error ("invalid %s name `%s'", usage, msg);
} else {
temp = (struct arglist *) xmalloc (sizeof (struct arglist));
temp->name = (U_CHAR *) xmalloc (bp - beg + 1);
- bcopy (beg, temp->name, bp - beg);
+ bcopy ((char *) beg, (char *) temp->name, bp - beg);
temp->name[bp - beg] = 0;
temp->next = token_ptrs;
token_ptrs = temp;
{
int length = limit - buf;
U_CHAR *copy = (U_CHAR *) xmalloc (length + 1);
- bcopy (buf, copy, length);
+ bcopy ((char *) buf, (char *) copy, length);
copy[length] = 0;
SKIP_WHITE_SPACE (copy);
error ("#error %s", copy);
{
int length = limit - buf;
U_CHAR *copy = (U_CHAR *) xmalloc (length + 1);
- bcopy (buf, copy, length);
+ bcopy ((char *) buf, (char *) copy, length);
copy[length] = 0;
SKIP_WHITE_SPACE (copy);
warning ("#warning %s", copy);
trybuf = expand_to_temp_buffer (buf, limit, 0, 0);
buf = (U_CHAR *) alloca (trybuf.bufp - trybuf.buf + 1);
- bcopy (trybuf.buf, buf, trybuf.bufp - trybuf.buf);
+ bcopy ((char *) trybuf.buf, (char *) buf, trybuf.bufp - trybuf.buf);
limit = buf + (trybuf.bufp - trybuf.buf);
len = (limit - buf);
free (trybuf.buf);
/* Output directive name. */
check_expand (op, 8);
- bcopy ("#ident ", op->bufp, 7);
+ bcopy ("#ident ", (char *) op->bufp, 7);
op->bufp += 7;
/* Output the expanded argument line. */
check_expand (op, len);
- bcopy (buf, op->bufp, len);
+ bcopy ((char *) buf, (char *) op->bufp, len);
op->bufp += len;
return 0;
skip = (hp == NULL) ^ (keyword->type == T_IFNDEF);
if (start_of_file && !skip) {
control_macro = (U_CHAR *) xmalloc (end - buf + 1);
- bcopy (buf, control_macro, end - buf);
+ bcopy ((char *) buf, (char *) control_macro, end - buf);
control_macro[end - buf] = 0;
}
}
check_expand (op, len + 1);
if (op->bufp > op->buf && op->bufp[-1] != '\n')
*op->bufp++ = '\n';
- bcopy (line_cmd_buf, op->bufp, len);
+ bcopy ((char *) line_cmd_buf, (char *) op->bufp, len);
op->bufp += len;
op->lineno = ip->lineno;
}
}
}
- bcopy (p1, xbuf + totlen, l1 - p1);
+ bcopy ((char *) p1, (char *) (xbuf + totlen), l1 - p1);
totlen += l1 - p1;
if (!traditional && !ap->raw_after) {
/* Ordinary expanded use of the argument.
xbuf[totlen++] = '\n';
xbuf[totlen++] = ' ';
}
- bcopy (arg->expanded, xbuf + totlen, arg->expand_length);
+ bcopy ((char *) arg->expanded, (char *) (xbuf + totlen),
+ arg->expand_length);
totlen += arg->expand_length;
if (!traditional) {
xbuf[totlen++] = '\n';
U_CHAR *buffer = (U_CHAR *) xmalloc (bufsize + extra + 1);
int final_start = 0;
- bcopy (ip->bufp, buffer, bufsize);
+ bcopy ((char *) ip->bufp, (char *) buffer, bufsize);
ip->bufp = bp;
ip->lineno += newlines;
bufsize += bp - ip->bufp;
extra += newlines;
buffer = (U_CHAR *) xrealloc (buffer, bufsize + extra + 1);
- bcopy (ip->bufp, buffer + bufsize - (bp - ip->bufp), bp - ip->bufp);
+ bcopy ((char *) ip->bufp, (char *) (buffer + bufsize - (bp - ip->bufp)),
+ bp - ip->bufp);
ip->bufp = bp;
ip->lineno += newlines;
}
/* Add a new environment variable */
environ = (char **) xmalloc (sizeof (char *) * (num_envs+2));
*environ = str;
- bcopy (old_environ, environ+1, sizeof (char *) * (num_envs+1));
+ bcopy ((char *) old_environ, (char *) (environ + 1),
+ sizeof (char *) * (num_envs+1));
+
return 0;
#endif /* VMS */
}
if (rw)
{
load_union_t *ptr = (load_union_t *) xmalloc (load_hdr->hdr.ldci_cmd_size);
- bcopy ((generic *)load_hdr, (generic *)ptr, load_hdr->hdr.ldci_cmd_size);
+ bcopy ((char *)load_hdr, (char *)ptr, load_hdr->hdr.ldci_cmd_size);
load_hdr = ptr;
/* null out old command map, because we will rewrite at the end. */
if (debug)
print_load_command (load_hdr, offset, i);
- bcopy ((generic *)load_hdr, (generic *)(obj + offset), size);
+ bcopy ((char *)load_hdr, (char *)(obj + offset), size);
offset += size;
}
}
= (unsigned HOST_WIDE_INT *) alloca (nregs * sizeof (HOST_WIDE_INT));
reg_sign_bit_copies = (char *) alloca (nregs * sizeof (char));
- bzero (reg_nonzero_bits, nregs * sizeof (HOST_WIDE_INT));
+ bzero ((char *) reg_nonzero_bits, nregs * sizeof (HOST_WIDE_INT));
bzero (reg_sign_bit_copies, nregs * sizeof (char));
reg_last_death = (rtx *) alloca (nregs * sizeof (rtx));
{
int nregs = combine_max_regno;
- bzero (reg_last_death, nregs * sizeof (rtx));
- bzero (reg_last_set, nregs * sizeof (rtx));
- bzero (reg_last_set_value, nregs * sizeof (rtx));
- bzero (reg_last_set_table_tick, nregs * sizeof (int));
- bzero (reg_last_set_label, nregs * sizeof (int));
+ 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 (reg_last_set_mode, nregs * sizeof (enum machine_mode));
- bzero (reg_last_set_nonzero_bits, nregs * sizeof (HOST_WIDE_INT));
+ 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));
}
\f
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 (&old->elem[0], &XVECEXP (newpat, 0, 0),
+ bcopy ((char *) &old->elem[0], (char *) &XVECEXP (newpat, 0, 0),
sizeof (old->elem[0]) * old->num_elem);
}
else
next_qty = max_reg;
- bzero (reg_tick, max_reg * sizeof (int));
+ bzero ((char *) reg_tick, max_reg * sizeof (int));
- bcopy (all_minus_one, reg_in_table, max_reg * sizeof (int));
- bcopy (consec_ints, reg_qty, max_reg * sizeof (int));
+ bcopy ((char *) all_minus_one, (char *) reg_in_table,
+ max_reg * sizeof (int));
+ bcopy ((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
}
}
- bzero (table, sizeof table);
+ bzero ((char *) table, sizeof table);
prev_insn = 0;
int first = 1, negate = 0, changed;
int i, j;
- bzero (ops, sizeof ops);
+ bzero ((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
/* Discard all the free elements of the previous function
since they are allocated in the temporarily obstack. */
- bzero (table, sizeof table);
+ bzero ((char *) table, sizeof table);
free_element_chain = 0;
n_elements_made = 0;
max_uid = get_max_uid ();
uid_cuid = (int *) alloca ((max_uid + 1) * sizeof (int));
- bzero (uid_cuid, (max_uid + 1) * sizeof (int));
+ bzero ((char *) uid_cuid, (max_uid + 1) * sizeof (int));
/* Compute the mapping from uids to cuids.
CUIDs are numbers assigned to insns, like uids,
int in_libcall = 0;
/* First count the number of times each register is used. */
- bzero (counts, sizeof (int) * nreg);
+ bzero ((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);
typevec_len = 100;
typevec = (enum typestatus *) xmalloc (typevec_len * sizeof typevec[0]);
- bzero (typevec, typevec_len * sizeof typevec[0]);
+ bzero ((char *) typevec, typevec_len * sizeof typevec[0]);
/* Convert Ltext into the appropriate format for local labels in case
the system doesn't insert underscores in front of user generated
if (next_type_number == typevec_len)
{
- typevec = (enum typestatus *) xrealloc (typevec, typevec_len * 2 * sizeof typevec[0]);
- bzero (typevec + typevec_len, typevec_len * sizeof typevec[0]);
+ int len = typevec_len * 2 * sizeof typevec[0];
+
+ typevec = (enum typestatus *) xrealloc (typevec, len);
+ bzero ((char *) (typevec + typevec_len), len);
typevec_len *= 2;
}
}
regno_pointer_flag = new;
new1 = (rtx *) oballoc (regno_pointer_flag_length * 2 * sizeof (rtx));
- bcopy (regno_reg_rtx, new1, regno_pointer_flag_length * sizeof (rtx));
- bzero (&new1[regno_pointer_flag_length],
+ bcopy ((char *) regno_reg_rtx, (char *) new1,
+ regno_pointer_flag_length * sizeof (rtx));
+ bzero ((char *) &new1[regno_pointer_flag_length],
regno_pointer_flag_length * sizeof (rtx));
regno_reg_rtx = new1;
register rtx copy;
copy = rtx_alloc (code);
- bcopy (x, copy, (sizeof (*copy) - sizeof (copy->fld)
- + sizeof (copy->fld[0]) * GET_RTX_LENGTH (code)));
+ bcopy ((char *) x, (char *) copy,
+ (sizeof (*copy) - sizeof (copy->fld)
+ + sizeof (copy->fld[0]) * GET_RTX_LENGTH (code)));
x = copy;
copied = 1;
}
bcopy (regno_pointer_flag, new, regno_pointer_flag_length);
new1 = (rtx *) oballoc (newlen * sizeof (rtx));
- bzero (new1, newlen * sizeof (rtx));
- bcopy (regno_reg_rtx, new1, regno_pointer_flag_length * sizeof (rtx));
+ bzero ((char *) new1, newlen * sizeof (rtx));
+ bcopy ((char *) regno_reg_rtx, (char *) new1,
+ regno_pointer_flag_length * sizeof (rtx));
regno_pointer_flag = new;
regno_reg_rtx = new1;
regno_reg_rtx
= (rtx *) oballoc (regno_pointer_flag_length * sizeof (rtx));
- bzero (regno_reg_rtx, regno_pointer_flag_length * sizeof (rtx));
+ bzero ((char *) regno_reg_rtx, regno_pointer_flag_length * sizeof (rtx));
/* Put copies of all the virtual register rtx into regno_reg_rtx. */
regno_reg_rtx[VIRTUAL_INCOMING_ARGS_REGNUM] = virtual_incoming_args_rtx;
rtx tem = rtx_alloc (CONST_DOUBLE);
union real_extract u;
- bzero (&u, sizeof u); /* Zero any holes in a structure. */
+ bzero ((char *) &u, sizeof u); /* Zero any holes in a structure. */
u.d = i == 0 ? dconst0 : i == 1 ? dconst1 : dconst2;
- bcopy (&u, &CONST_DOUBLE_LOW (tem), sizeof u);
+ bcopy ((char *) &u, (char *) &CONST_DOUBLE_LOW (tem), sizeof u);
CONST_DOUBLE_MEM (tem) = cc0_rtx;
PUT_MODE (tem, mode);
best_alg is normally undefined, and this is a critical function. */
alg_out->ops = best_alg->ops + 1;
alg_out->cost = cost_limit;
- bcopy (best_alg->op, alg_out->op, alg_out->ops * sizeof *alg_out->op);
- bcopy (best_alg->log, alg_out->log, alg_out->ops * sizeof *alg_out->log);
+ bcopy ((char *) best_alg->op, (char *) alg_out->op,
+ alg_out->ops * sizeof *alg_out->op);
+ bcopy ((char *) best_alg->log, (char *) alg_out->log,
+ alg_out->ops * sizeof *alg_out->log);
}
\f
/* Perform a multiplication and return an rtx for the result.
allocate_for_life_analysis ();
reg_next_use = (rtx *) alloca (nregs * sizeof (rtx));
- bzero (reg_next_use, nregs * sizeof (rtx));
+ bzero ((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. */
- basic_block_live_at_end = (regset *) alloca (n_basic_blocks * sizeof (regset));
+ basic_block_live_at_end
+ = (regset *) alloca (n_basic_blocks * sizeof (regset));
+
/* Don't use alloca since that leads to a crash rather than an error message
if there isn't enough space.
Don't use oballoc since we may need to allocate other things during
this function on the temporary obstack. */
tem = (regset) obstack_alloc (&flow_obstack, n_basic_blocks * regset_bytes);
- bzero (tem, n_basic_blocks * regset_bytes);
- init_regset_vector (basic_block_live_at_end, tem, n_basic_blocks, regset_bytes);
+ bzero ((char *) tem, n_basic_blocks * regset_bytes);
+ init_regset_vector (basic_block_live_at_end, tem,
+ n_basic_blocks, regset_bytes);
- basic_block_new_live_at_end = (regset *) alloca (n_basic_blocks * sizeof (regset));
+ basic_block_new_live_at_end
+ = (regset *) alloca (n_basic_blocks * sizeof (regset));
tem = (regset) obstack_alloc (&flow_obstack, n_basic_blocks * regset_bytes);
- bzero (tem, n_basic_blocks * regset_bytes);
- init_regset_vector (basic_block_new_live_at_end, tem, n_basic_blocks, regset_bytes);
+ bzero ((char *) tem, n_basic_blocks * regset_bytes);
+ init_regset_vector (basic_block_new_live_at_end, tem,
+ n_basic_blocks, regset_bytes);
- basic_block_significant = (regset *) alloca (n_basic_blocks * sizeof (regset));
+ basic_block_significant
+ = (regset *) alloca (n_basic_blocks * sizeof (regset));
tem = (regset) obstack_alloc (&flow_obstack, n_basic_blocks * regset_bytes);
- bzero (tem, n_basic_blocks * regset_bytes);
- init_regset_vector (basic_block_significant, tem, n_basic_blocks, regset_bytes);
+ bzero ((char *) tem, n_basic_blocks * regset_bytes);
+ init_regset_vector (basic_block_significant, tem,
+ n_basic_blocks, regset_bytes);
/* Record which insns refer to any volatile memory
or for any reason can't be deleted just because they are dead stores.
{
/* Update the basic_block_live_at_start
by propagation backwards through the block. */
- bcopy (basic_block_new_live_at_end[i],
- basic_block_live_at_end[i], regset_bytes);
- bcopy (basic_block_live_at_end[i],
- basic_block_live_at_start[i], regset_bytes);
+ bcopy ((char *) basic_block_new_live_at_end[i],
+ (char *) basic_block_live_at_end[i], regset_bytes);
+ bcopy ((char *) basic_block_live_at_end[i],
+ (char *) basic_block_live_at_start[i], regset_bytes);
propagate_block (basic_block_live_at_start[i],
basic_block_head[i], basic_block_end[i], 0,
first_pass ? basic_block_significant[i]
regset_bytes = regset_size * sizeof (*(regset)0);
reg_n_refs = (int *) oballoc (max_regno * sizeof (int));
- bzero (reg_n_refs, max_regno * sizeof (int));
+ bzero ((char *) reg_n_refs, max_regno * sizeof (int));
reg_n_sets = (short *) oballoc (max_regno * sizeof (short));
- bzero (reg_n_sets, max_regno * sizeof (short));
+ bzero ((char *) reg_n_sets, max_regno * sizeof (short));
reg_n_deaths = (short *) oballoc (max_regno * sizeof (short));
- bzero (reg_n_deaths, max_regno * sizeof (short));
+ bzero ((char *) reg_n_deaths, max_regno * sizeof (short));
reg_live_length = (int *) oballoc (max_regno * sizeof (int));
- bzero (reg_live_length, max_regno * sizeof (int));
+ bzero ((char *) reg_live_length, max_regno * sizeof (int));
reg_n_calls_crossed = (int *) oballoc (max_regno * sizeof (int));
- bzero (reg_n_calls_crossed, max_regno * sizeof (int));
+ bzero ((char *) reg_n_calls_crossed, max_regno * sizeof (int));
reg_basic_block = (int *) oballoc (max_regno * sizeof (int));
for (i = 0; i < max_regno; i++)
reg_basic_block[i] = REG_BLOCK_UNKNOWN;
- basic_block_live_at_start = (regset *) oballoc (n_basic_blocks * sizeof (regset));
+ basic_block_live_at_start
+ = (regset *) oballoc (n_basic_blocks * sizeof (regset));
tem = (regset) oballoc (n_basic_blocks * regset_bytes);
- bzero (tem, n_basic_blocks * regset_bytes);
- init_regset_vector (basic_block_live_at_start, tem, n_basic_blocks, regset_bytes);
+ bzero ((char *) tem, n_basic_blocks * regset_bytes);
+ init_regset_vector (basic_block_live_at_start, tem,
+ n_basic_blocks, regset_bytes);
regs_live_at_setjmp = (regset) oballoc (regset_bytes);
- bzero (regs_live_at_setjmp, regset_bytes);
+ bzero ((char *) regs_live_at_setjmp, regset_bytes);
}
/* Make each element of VECTOR point at a regset,
num_scratch = 0;
maxlive = (regset) alloca (regset_bytes);
- bcopy (old, maxlive, regset_bytes);
+ bcopy ((char *) old, (char *) maxlive, regset_bytes);
regs_sometimes_live
= (struct sometimes *) alloca (max_regno * sizeof (struct sometimes));
encode (arg1, l1, h1);
encode (arg2, l2, h2);
- bzero (prod, sizeof prod);
+ bzero ((char *) prod, sizeof prod);
for (i = 0; i < MAX_SHORTS; i++)
for (j = 0; j < MAX_SHORTS; j++)
goto finish_up;
}
- bzero (quo, sizeof quo);
+ bzero ((char *) quo, sizeof quo);
- bzero (num, sizeof num); /* to zero 9th element */
- bzero (den, sizeof den);
+ bzero ((char *) num, sizeof num); /* to zero 9th element */
+ bzero ((char *) den, sizeof den);
encode (num, lnum, hnum);
encode (den, lden, hden);
/* Detect when real constants are equal. */
if (TREE_CODE (arg0) == TREE_CODE (arg1)
&& TREE_CODE (arg0) == REAL_CST)
- return !bcmp (&TREE_REAL_CST (arg0), &TREE_REAL_CST (arg1),
+ return !bcmp ((char *) &TREE_REAL_CST (arg0),
+ (char *) &TREE_REAL_CST (arg1),
sizeof (REAL_VALUE_TYPE));
if (only_const)
}
parm_reg_stack_loc = (rtx *) oballoc (nparmregs * sizeof (rtx));
- bzero (parm_reg_stack_loc, nparmregs * sizeof (rtx));
+ bzero ((char *) parm_reg_stack_loc, nparmregs * sizeof (rtx));
#ifdef INIT_CUMULATIVE_INCOMING_ARGS
INIT_CUMULATIVE_INCOMING_ARGS (args_so_far, fntype, NULL_RTX);
nparmregs = regno + 5;
new = (rtx *) oballoc (nparmregs * sizeof (rtx));
- bcopy (parm_reg_stack_loc, new, old_nparmregs * sizeof (rtx));
- bzero (new + old_nparmregs,
+ bcopy ((char *) parm_reg_stack_loc, (char *) new,
+ old_nparmregs * sizeof (rtx));
+ bzero ((char *) (new + old_nparmregs),
(nparmregs - old_nparmregs) * sizeof (rtx));
parm_reg_stack_loc = new;
}
= ((struct compiler *)
xrealloc (compilers, (n_compilers + 2) * sizeof (struct compiler)));
compilers[n_compilers].suffix = suffix;
- bzero (compilers[n_compilers].spec,
+ bzero ((char *) compilers[n_compilers].spec,
sizeof compilers[n_compilers].spec);
compilers[n_compilers].spec[0] = spec;
n_compilers++;
- bzero (&compilers[n_compilers], sizeof compilers[n_compilers]);
+ bzero ((char *) &compilers[n_compilers],
+ sizeof compilers[n_compilers]);
}
if (*suffix == 0)
/* Add a new environment variable */
environ = (char **) xmalloc (sizeof (char *) * (num_envs+2));
*environ = str;
- bcopy (old_environ, environ+1, sizeof (char *) * (num_envs+1));
+ bcopy ((char *) old_environ, (char *) (environ + 1),
+ sizeof (char *) * (num_envs+1));
#endif /* VMS */
}
This means one element containing 0s, as a terminator. */
compilers = (struct compiler *) xmalloc (sizeof default_compilers);
- bcopy (default_compilers, compilers, sizeof default_compilers);
+ bcopy ((char *) default_compilers, (char *) compilers,
+ sizeof default_compilers);
n_compilers = n_default_compilers;
/* Read specs from a file if there is one. */
that correspond to the input files. */
outfiles = (char **) xmalloc (n_infiles * sizeof (char *));
- bzero (outfiles, n_infiles * sizeof (char *));
+ bzero ((char *) outfiles, n_infiles * sizeof (char *));
/* Record which files were specified explicitly as link input. */
language = cp->spec[0] + 1;
new = (struct compiler *) xmalloc (sizeof (struct compiler));
new->suffix = cp->suffix;
- bcopy (lookup_compiler (NULL_PTR, 0, language)->spec,
- new->spec, sizeof new->spec);
+ bcopy ((char *) lookup_compiler (NULL_PTR, 0, language)->spec,
+ (char *) new->spec, sizeof new->spec);
return new;
}
/* A non-alias entry: return it. */
* sizeof (struct function_unit_op *));
for (unit = units, i = 0; unit; i += unit->num_opclasses, unit = unit->next)
- bcopy (unit_ops[unit->num], &op_array[i],
+ bcopy ((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
/* This lets us free all storage allocated below, if appropriate. */
first_spacer = (char *) obstack_finish (rtl_obstack);
- bcopy (&XVECEXP (exp, 0, 0), tests, len * sizeof (rtx));
+ bcopy ((char *) &XVECEXP (exp, 0, 0), (char *) tests, len * sizeof (rtx));
/* See if default value needs simplification. */
if (GET_CODE (defval) == COND)
rtx newexp = rtx_alloc (COND);
XVEC (newexp, 0) = rtvec_alloc (len);
- bcopy (tests, &XVECEXP (newexp, 0, 0), len * sizeof (rtx));
+ bcopy ((char *) tests, (char *) &XVECEXP (newexp, 0, 0),
+ len * sizeof (rtx));
XEXP (newexp, 1) = new_defval;
return newexp;
}
insn_code_values
= (struct attr_value_list **) alloca ((insn_code_number + 2)
* sizeof (struct attr_value_list *));
- bzero (insn_code_values,
+ bzero ((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. */
insn_code_values += 2;
PUT_MODE (copy, GET_MODE (orig));
RTX_UNCHANGING_P (copy) = 1;
- bcopy (&XEXP (orig, 0), &XEXP (copy, 0),
+ bcopy ((char *) &XEXP (orig, 0), (char *) &XEXP (copy, 0),
GET_RTX_LENGTH (GET_CODE (copy)) * sizeof (rtx));
return copy;
#endif
/* Initialize the shared-hard-reg mapping
from the list of pairs that may share. */
reg_may_share = (int *) alloca (max_regno * sizeof (int));
- bzero (reg_may_share, max_regno * sizeof (int));
+ bzero ((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));
allocno_calls_crossed = (int *) alloca (max_allocno * sizeof (int));
allocno_n_refs = (int *) alloca (max_allocno * sizeof (int));
allocno_live_length = (int *) alloca (max_allocno * sizeof (int));
- bzero (allocno_size, max_allocno * sizeof (int));
- bzero (allocno_calls_crossed, max_allocno * sizeof (int));
- bzero (allocno_n_refs, max_allocno * sizeof (int));
- bzero (allocno_live_length, 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));
for (i = FIRST_PSEUDO_REGISTER; i < max_regno; i++)
if (reg_allocno[i] >= 0)
/* 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 (local_reg_live_length, sizeof local_reg_live_length);
- bzero (local_reg_n_refs, sizeof local_reg_n_refs);
+ bzero ((char *) local_reg_live_length, sizeof local_reg_live_length);
+ bzero ((char *) local_reg_n_refs, sizeof local_reg_n_refs);
for (i = FIRST_PSEUDO_REGISTER; i < max_regno; i++)
if (reg_allocno[i] < 0 && reg_renumber[i] >= 0)
{
hard_reg_conflicts
= (HARD_REG_SET *) alloca (max_allocno * sizeof (HARD_REG_SET));
- bzero (hard_reg_conflicts, max_allocno * sizeof (HARD_REG_SET));
+ bzero ((char *) hard_reg_conflicts, max_allocno * sizeof (HARD_REG_SET));
hard_reg_preferences
= (HARD_REG_SET *) alloca (max_allocno * sizeof (HARD_REG_SET));
- bzero (hard_reg_preferences, max_allocno * sizeof (HARD_REG_SET));
+ bzero ((char *) hard_reg_preferences, max_allocno * sizeof (HARD_REG_SET));
hard_reg_copy_preferences
= (HARD_REG_SET *) alloca (max_allocno * sizeof (HARD_REG_SET));
- bzero (hard_reg_copy_preferences, max_allocno * sizeof (HARD_REG_SET));
+ bzero ((char *) hard_reg_copy_preferences,
+ max_allocno * sizeof (HARD_REG_SET));
hard_reg_full_preferences
= (HARD_REG_SET *) alloca (max_allocno * sizeof (HARD_REG_SET));
- bzero (hard_reg_full_preferences, max_allocno * sizeof (HARD_REG_SET));
+ bzero ((char *) hard_reg_full_preferences,
+ max_allocno * sizeof (HARD_REG_SET));
regs_someone_prefers
= (HARD_REG_SET *) alloca (max_allocno * sizeof (HARD_REG_SET));
- bzero (regs_someone_prefers, max_allocno * sizeof (HARD_REG_SET));
+ bzero ((char *) regs_someone_prefers, max_allocno * sizeof (HARD_REG_SET));
allocno_row_words = (max_allocno + INT_BITS - 1) / INT_BITS;
conflicts = (INT_TYPE *) alloca (max_allocno * allocno_row_words
* sizeof (INT_TYPE));
- bzero (conflicts, max_allocno * allocno_row_words
- * sizeof (INT_TYPE));
+ bzero ((char *) conflicts,
+ max_allocno * allocno_row_words * sizeof (INT_TYPE));
allocnos_live = (INT_TYPE *) alloca (allocno_row_words * sizeof (INT_TYPE));
for (b = 0; b < n_basic_blocks; b++)
{
- bzero (allocnos_live, allocno_row_words * sizeof (INT_TYPE));
+ bzero ((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.
+ 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 (parmdecl_map, max_parm_reg * sizeof (tree));
+ bzero ((char *) parmdecl_map, max_parm_reg * sizeof (tree));
arg_vector = rtvec_alloc (list_length (DECL_ARGUMENTS (fndecl)));
for (parms = DECL_ARGUMENTS (fndecl), i = 0;
reg_map[i] = (rtx)obstack_copy (function_maybepermanent_obstack,
regno_reg_rtx[i], len);
- bcopy (reg_map + LAST_VIRTUAL_REGISTER + 1,
- regno_reg_rtx + LAST_VIRTUAL_REGISTER + 1,
+ bcopy ((char *) (reg_map + LAST_VIRTUAL_REGISTER + 1),
+ (char *) (regno_reg_rtx + LAST_VIRTUAL_REGISTER + 1),
(max_reg - (LAST_VIRTUAL_REGISTER + 1)) * sizeof (rtx));
/* Likewise each label rtx must have a unique rtx as its copy. */
/* Record the mapping of old insns to copied insns. */
insn_map = (rtx *) alloca (max_uid * sizeof (rtx));
- bzero (insn_map, max_uid * sizeof (rtx));
+ bzero ((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 ();
/* Replace this rtx with a copy of itself. */
x = rtx_alloc (code);
- bcopy (orig, x, (sizeof (*x) - sizeof (x->fld)
- + sizeof (x->fld[0]) * GET_RTX_LENGTH (code)));
+ bcopy ((char *) orig, (char *) x,
+ (sizeof (*x) - sizeof (x->fld)
+ + sizeof (x->fld[0]) * GET_RTX_LENGTH (code)));
/* Now scan the subexpressions recursively.
We can store any replaced subexpressions directly into X
map->fndecl = fndecl;
map->reg_map = (rtx *) alloca (max_regno * sizeof (rtx));
- bzero (map->reg_map, max_regno * sizeof (rtx));
+ bzero ((char *) map->reg_map, max_regno * sizeof (rtx));
map->label_map = (rtx *)alloca ((max_labelno - min_labelno) * sizeof (rtx));
map->label_map -= min_labelno;
map->insn_map = (rtx *) alloca (INSN_UID (header) * sizeof (rtx));
- bzero (map->insn_map, INSN_UID (header) * sizeof (rtx));
+ bzero ((char *) map->insn_map, INSN_UID (header) * sizeof (rtx));
map->min_insnno = 0;
map->max_insnno = INSN_UID (header);
map->const_equiv_map
= (rtx *)alloca (map->const_equiv_map_size * sizeof (rtx));
- bzero (map->const_equiv_map, map->const_equiv_map_size * sizeof (rtx));
+ bzero ((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 (map->const_age_map, map->const_equiv_map_size * sizeof (unsigned));
+ bzero ((char *) map->const_age_map,
+ map->const_equiv_map_size * sizeof (unsigned));
map->const_age = 0;
/* Record the current insn in case we have to set up pointers to frame
we make. */
max_jump_chain = max_uid * 14 / 10;
jump_chain = (rtx *) alloca (max_jump_chain * sizeof (rtx));
- bzero (jump_chain, max_jump_chain * sizeof (rtx));
+ bzero ((char *) jump_chain, max_jump_chain * sizeof (rtx));
/* Mark the label each jump jumps to.
Combine consecutive labels, and count uses of labels.
if (reg_map == 0)
{
reg_map = (rtx *) alloca (max_reg * sizeof (rtx));
- bzero (reg_map, max_reg * sizeof (rtx));
+ bzero ((char *) reg_map, max_reg * sizeof (rtx));
}
REG_LOOP_TEST_P (SET_DEST (set)) = 1;
bzero (modified_regs, max_reg * sizeof (char));
modified_mem = 0;
- bcopy (all_reset, same_regs, max_reg * sizeof (int));
+ bcopy ((char *) all_reset, (char *) same_regs,
+ max_reg * sizeof (int));
num_same_regs = 0;
label = JUMP_LABEL (b1);
scratch_list_length = max_qty;
scratch_list = (rtx *) xmalloc (scratch_list_length * sizeof (rtx));
- bzero (scratch_list, scratch_list_length * sizeof (rtx));
+ bzero ((char *) scratch_list, scratch_list_length * sizeof (rtx));
scratch_block = (int *) xmalloc (scratch_list_length * sizeof (int));
- bzero (scratch_block, scratch_list_length * sizeof (int));
+ bzero ((char *) scratch_block, scratch_list_length * sizeof (int));
scratch_index = 0;
qty_phys_reg = (short *) alloca (max_qty * sizeof (short));
- qty_phys_copy_sugg = (HARD_REG_SET *) alloca (max_qty * sizeof (HARD_REG_SET));
+ qty_phys_copy_sugg
+ = (HARD_REG_SET *) alloca (max_qty * sizeof (HARD_REG_SET));
qty_phys_num_copy_sugg = (short *) alloca (max_qty * sizeof (short));
qty_phys_sugg = (HARD_REG_SET *) alloca (max_qty * sizeof (HARD_REG_SET));
qty_phys_num_sugg = (short *) alloca (max_qty * sizeof (short));
qty_scratch_rtx = (rtx *) alloca (max_qty * sizeof (rtx));
qty_first_reg = (int *) alloca (max_qty * sizeof (int));
qty_size = (int *) alloca (max_qty * sizeof (int));
- qty_mode = (enum machine_mode *) alloca (max_qty * sizeof (enum machine_mode));
+ qty_mode
+ = (enum machine_mode *) alloca (max_qty * sizeof (enum machine_mode));
qty_n_calls_crossed = (int *) alloca (max_qty * sizeof (int));
- qty_min_class = (enum reg_class *) alloca (max_qty * sizeof (enum reg_class));
- qty_alternate_class = (enum reg_class *) alloca (max_qty * sizeof (enum reg_class));
+ qty_min_class
+ = (enum reg_class *) alloca (max_qty * sizeof (enum reg_class));
+ qty_alternate_class
+ = (enum reg_class *) alloca (max_qty * sizeof (enum reg_class));
qty_n_refs = (int *) alloca (max_qty * sizeof (int));
reg_qty = (int *) alloca (max_regno * sizeof (int));
else
{
#define CLEAR(vector) \
- bzero ((vector), (sizeof (*(vector))) * next_qty);
+ bzero ((char *) (vector), (sizeof (*(vector))) * next_qty);
CLEAR (qty_scratch_rtx);
CLEAR (qty_phys_copy_sugg);
rtx *reg_equiv_replacement = (rtx *) alloca (max_regno * sizeof (rtx *));
rtx insn;
- bzero (reg_equiv_init_insn, max_regno * sizeof (rtx *));
- bzero (reg_equiv_replacement, max_regno * sizeof (rtx *));
+ bzero ((char *) reg_equiv_init_insn, max_regno * sizeof (rtx *));
+ bzero ((char *) reg_equiv_replacement, max_regno * sizeof (rtx *));
init_alias_analysis ();
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 (regs_live_at, (2 * insn_count + 2) * sizeof (HARD_REG_SET));
+ bzero ((char *) regs_live_at, (2 * insn_count + 2) * sizeof (HARD_REG_SET));
/* Initialize table of hardware registers currently live. */
uid_luid = (int *) alloca (max_uid_for_loop * sizeof (int));
uid_loop_num = (int *) alloca (max_uid_for_loop * sizeof (int));
- bzero (uid_luid, max_uid_for_loop * sizeof (int));
- bzero (uid_loop_num, 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));
/* Allocate tables for recording each loop. We set each entry, so they need
not be zeroed. */
the setting of register I. If this loop has calls, set
reg_single_usage[I]. */
- bzero (n_times_set, nregs * sizeof (short));
+ bzero ((char *) n_times_set, nregs * sizeof (short));
bzero (may_not_optimize, nregs);
if (loop_has_call)
{
reg_single_usage = (rtx *) alloca (nregs * sizeof (rtx));
- bzero (reg_single_usage, nregs * sizeof (rtx));
+ bzero ((char *) reg_single_usage, nregs * sizeof (rtx));
}
count_loop_regs_set (loop_top ? loop_top : loop_start, end,
for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
may_not_optimize[i] = 1, n_times_set[i] = 1;
- bcopy (n_times_set, n_times_used, nregs * sizeof (short));
+ bcopy ((char *) n_times_set, (char *) n_times_used, nregs * sizeof (short));
if (loop_dump_stream)
{
char *already_moved = (char *) alloca (nregs);
bzero (already_moved, nregs);
- bzero (reg_map, nregs * sizeof (rtx));
+ bzero ((char *) reg_map, nregs * sizeof (rtx));
num_movables = 0;
register int count = 0;
register rtx dest;
- bzero (last_set, nregs * sizeof (rtx));
+ bzero ((char *) last_set, nregs * sizeof (rtx));
for (insn = from; insn != to; insn = NEXT_INSN (insn))
{
if (GET_RTX_CLASS (GET_CODE (insn)) == 'i')
}
}
}
+
if (GET_CODE (insn) == CODE_LABEL || GET_CODE (insn) == JUMP_INSN)
- bzero (last_set, nregs * sizeof (rtx));
+ bzero ((char *) last_set, nregs * sizeof (rtx));
}
*count_ptr = count;
}
tree node;
{
char *object = (char *) oballoc (0);
+
table = (struct bucket **) oballoc (HASH_SIZE * sizeof (struct bucket *));
- bzero (table, HASH_SIZE * sizeof (struct bucket *));
+ bzero ((char *) table, HASH_SIZE * sizeof (struct bucket *));
print_node (stderr, "", node, 0);
table = 0;
obfree (object);
#define REAL_VALUE_FROM_CONST_DOUBLE(to, from) \
do { union real_extract u; \
- bcopy (&CONST_DOUBLE_LOW ((from)), &u, sizeof u); \
+ bcopy ((char *) &CONST_DOUBLE_LOW ((from)), (char *) &u, sizeof u); \
to = u.d; } while (0)
/* Return a CONST_DOUBLE with value R and mode M. */
/* Compute number of hard regs in each class. */
- bzero (reg_class_size, sizeof reg_class_size);
+ bzero ((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))
{
/* Zero out our accumulation of the cost of each class for each reg. */
- bzero (costs, nregs * sizeof (struct costs));
+ bzero ((char *) costs, nregs * sizeof (struct costs));
#ifdef FORBIDDEN_INC_DEC_CLASSES
bzero (in_inc_dec, nregs);
= (short *) oballoc (highest_regno_in_uid_map * sizeof (short));
}
- bzero (regno_first_uid, highest_regno_in_uid_map * sizeof (int));
- bzero (regno_last_uid, highest_regno_in_uid_map * sizeof (int));
- bzero (regno_last_note_uid, highest_regno_in_uid_map * sizeof (int));
- bzero (reg_n_sets, highest_regno_in_uid_map * sizeof (short));
+ bzero ((char *) regno_first_uid, highest_regno_in_uid_map * sizeof (int));
+ bzero ((char *) regno_last_uid, highest_regno_in_uid_map * sizeof (int));
+ bzero ((char *) regno_last_note_uid,
+ highest_regno_in_uid_map * sizeof (int));
+ bzero ((char *) reg_n_sets, highest_regno_in_uid_map * sizeof (short));
max_parallel = 3;
void
clear_secondary_mem ()
{
- bzero (secondary_memlocs, sizeof secondary_memlocs);
+ bzero ((char *) secondary_memlocs, sizeof secondary_memlocs);
}
#endif /* SECONDARY_MEMORY_NEEDED */
\f
/* The eliminated forms of any secondary memory locations are per-insn, so
clear them out here. */
- bzero (secondary_memlocs_elim, sizeof secondary_memlocs_elim);
+ bzero ((char *) secondary_memlocs_elim, sizeof secondary_memlocs_elim);
#endif
/* Find what kind of insn this is. NOPERANDS gets number of operands.
constraints, operand_mode);
if (noperands > 0)
{
- bcopy (constraints, constraints1, noperands * sizeof (char *));
+ bcopy ((char *) constraints, (char *) constraints1,
+ noperands * sizeof (char *));
n_alternatives = n_occurrences (',', constraints[0]) + 1;
for (i = 1; i < noperands; i++)
if (n_alternatives != n_occurrences (',', constraints[i]) + 1)
pref_or_nothing[commutative] = pref_or_nothing[commutative + 1];
pref_or_nothing[commutative + 1] = t;
- bcopy (constraints1, constraints, noperands * sizeof (char *));
+ bcopy ((char *) constraints1, (char *) constraints,
+ noperands * sizeof (char *));
goto try_swapped;
}
else
bcopy (regs_ever_live, regs_explicitly_used, sizeof regs_ever_live);
/* We don't have a stack slot for any spill reg yet. */
- bzero (spill_stack_slot, sizeof spill_stack_slot);
- bzero (spill_stack_slot_width, sizeof spill_stack_slot_width);
+ bzero ((char *) spill_stack_slot, sizeof spill_stack_slot);
+ bzero ((char *) spill_stack_slot_width, sizeof spill_stack_slot_width);
/* Initialize the save area information for caller-save, in case some
are needed. */
be substituted eventually by altering the REG-rtx's. */
reg_equiv_constant = (rtx *) alloca (max_regno * sizeof (rtx));
- bzero (reg_equiv_constant, max_regno * sizeof (rtx));
+ bzero ((char *) reg_equiv_constant, max_regno * sizeof (rtx));
reg_equiv_memory_loc = (rtx *) alloca (max_regno * sizeof (rtx));
- bzero (reg_equiv_memory_loc, max_regno * sizeof (rtx));
+ bzero ((char *) reg_equiv_memory_loc, max_regno * sizeof (rtx));
reg_equiv_mem = (rtx *) alloca (max_regno * sizeof (rtx));
- bzero (reg_equiv_mem, max_regno * sizeof (rtx));
+ bzero ((char *) reg_equiv_mem, max_regno * sizeof (rtx));
reg_equiv_init = (rtx *) alloca (max_regno * sizeof (rtx));
- bzero (reg_equiv_init, max_regno * sizeof (rtx));
+ bzero ((char *) reg_equiv_init, max_regno * sizeof (rtx));
reg_equiv_address = (rtx *) alloca (max_regno * sizeof (rtx));
- bzero (reg_equiv_address, max_regno * sizeof (rtx));
+ bzero ((char *) reg_equiv_address, max_regno * sizeof (rtx));
reg_max_ref_width = (int *) alloca (max_regno * sizeof (int));
- bzero (reg_max_ref_width, max_regno * sizeof (int));
+ bzero ((char *) reg_max_ref_width, max_regno * sizeof (int));
cannot_omit_stores = (char *) alloca (max_regno);
bzero (cannot_omit_stores, max_regno);
if (global)
for (i = 0; i < N_REG_CLASSES; i++)
{
- basic_block_needs[i] = (char *)alloca (n_basic_blocks);
+ basic_block_needs[i] = (char *) alloca (n_basic_blocks);
bzero (basic_block_needs[i], n_basic_blocks);
}
static char *reg_class_names[] = REG_CLASS_NAMES;
something_changed = 0;
- bzero (max_needs, sizeof max_needs);
- bzero (max_groups, sizeof max_groups);
- bzero (max_nongroups, sizeof max_nongroups);
- bzero (max_needs_insn, sizeof max_needs_insn);
- bzero (max_groups_insn, sizeof max_groups_insn);
- bzero (max_nongroups_insn, sizeof max_nongroups_insn);
- bzero (group_size, sizeof group_size);
+ bzero ((char *) max_needs, sizeof max_needs);
+ bzero ((char *) max_groups, sizeof max_groups);
+ bzero ((char *) max_nongroups, sizeof max_nongroups);
+ bzero ((char *) max_needs_insn, sizeof max_needs_insn);
+ bzero ((char *) max_groups_insn, sizeof max_groups_insn);
+ bzero ((char *) max_nongroups_insn, sizeof max_nongroups_insn);
+ bzero ((char *) group_size, sizeof group_size);
for (i = 0; i < N_REG_CLASSES; i++)
group_mode[i] = VOIDmode;
num_not_at_initial_offset = 0;
- bzero (&offsets_known_at[get_first_label_num ()], num_labels);
+ bzero ((char *) &offsets_known_at[get_first_label_num ()], num_labels);
/* Set a known offset for each forced label to be at the initial offset
of each elimination. We do this because we assume that all
continue;
something_needs_reloads = 1;
- bzero (&insn_needs, sizeof insn_needs);
+ bzero ((char *) &insn_needs, sizeof insn_needs);
/* Count each reload once in every class
containing the reload's own class. */
if (new != XEXP (x, i) && ! copied)
{
rtx new_x = rtx_alloc (code);
- bcopy (x, new_x, (sizeof (*new_x) - sizeof (new_x->fld)
- + (sizeof (new_x->fld[0])
- * GET_RTX_LENGTH (code))));
+ bcopy ((char *) x, (char *) new_x,
+ (sizeof (*new_x) - sizeof (new_x->fld)
+ + sizeof (new_x->fld[0]) * GET_RTX_LENGTH (code)));
x = new_x;
copied = 1;
}
if (! copied)
{
rtx new_x = rtx_alloc (code);
- bcopy (x, new_x, (sizeof (*new_x) - sizeof (new_x->fld)
- + (sizeof (new_x->fld[0])
- * GET_RTX_LENGTH (code))));
+ bcopy ((char *) x, (char *) new_x,
+ (sizeof (*new_x) - sizeof (new_x->fld)
+ + (sizeof (new_x->fld[0])
+ * GET_RTX_LENGTH (code))));
x = new_x;
copied = 1;
}
rtx x;
rtx after_call = 0;
- bzero (spill_reg_rtx, sizeof spill_reg_rtx);
- bzero (spill_reg_store, sizeof spill_reg_store);
+ bzero ((char *) spill_reg_rtx, sizeof spill_reg_rtx);
+ bzero ((char *) spill_reg_store, sizeof spill_reg_store);
reg_last_reload_reg = (rtx *) alloca (max_regno * sizeof (rtx));
- bzero (reg_last_reload_reg, max_regno * sizeof (rtx));
+ bzero ((char *) reg_last_reload_reg, max_regno * sizeof (rtx));
reg_has_output_reload = (char *) alloca (max_regno);
for (i = 0; i < n_spills; i++)
{
HARD_REG_SET save_reload_reg_used_at_all;
bzero (reload_inherited, MAX_RELOADS);
- bzero (reload_inheritance_insn, MAX_RELOADS * sizeof (rtx));
- bzero (reload_override_in, MAX_RELOADS * sizeof (rtx));
+ bzero ((char *) reload_inheritance_insn, MAX_RELOADS * sizeof (rtx));
+ bzero ((char *) reload_override_in, MAX_RELOADS * sizeof (rtx));
CLEAR_HARD_REG_SET (reload_reg_used);
CLEAR_HARD_REG_SET (reload_reg_used_at_all);
if (n_reloads > 1)
qsort (reload_order, n_reloads, sizeof (short), reload_reg_class_lower);
- bcopy (reload_reg_rtx, save_reload_reg_rtx, sizeof reload_reg_rtx);
+ bcopy ((char *) reload_reg_rtx, (char *) save_reload_reg_rtx,
+ sizeof reload_reg_rtx);
bcopy (reload_inherited, save_reload_inherited, sizeof reload_inherited);
- bcopy (reload_inheritance_insn, save_reload_inheritance_insn,
+ bcopy ((char *) reload_inheritance_insn,
+ (char *) save_reload_inheritance_insn,
sizeof reload_inheritance_insn);
- bcopy (reload_override_in, save_reload_override_in,
+ bcopy ((char *) reload_override_in, (char *) save_reload_override_in,
sizeof reload_override_in);
- bcopy (reload_spill_index, save_reload_spill_index,
+ bcopy ((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);
/* Loop around and try without any inheritance. */
/* First undo everything done by the failed attempt
to allocate with inheritance. */
- bcopy (save_reload_reg_rtx, reload_reg_rtx, sizeof reload_reg_rtx);
- bcopy (save_reload_inherited, reload_inherited, sizeof reload_inherited);
- bcopy (save_reload_inheritance_insn, reload_inheritance_insn,
+ bcopy ((char *) save_reload_reg_rtx, (char *) reload_reg_rtx,
+ sizeof reload_reg_rtx);
+ bcopy ((char *) save_reload_inherited, (char *) reload_inherited,
+ sizeof reload_inherited);
+ bcopy ((char *) save_reload_inheritance_insn,
+ (char *) reload_inheritance_insn,
sizeof reload_inheritance_insn);
- bcopy (save_reload_override_in, reload_override_in,
+ bcopy ((char *) save_reload_override_in, (char *) reload_override_in,
sizeof reload_override_in);
- bcopy (save_reload_spill_index, reload_spill_index,
+ bcopy ((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);
reg_known_value
= (rtx *) oballoc ((maxreg-FIRST_PSEUDO_REGISTER) * sizeof (rtx))
- FIRST_PSEUDO_REGISTER;
- bzero (reg_known_value+FIRST_PSEUDO_REGISTER,
+ bzero ((char *) (reg_known_value + FIRST_PSEUDO_REGISTER),
(maxreg-FIRST_PSEUDO_REGISTER) * sizeof (rtx));
reg_known_equiv_p
- = (char *) oballoc ((maxreg-FIRST_PSEUDO_REGISTER) * sizeof (char))
+ = (char *) oballoc ((maxreg -FIRST_PSEUDO_REGISTER) * sizeof (char))
- FIRST_PSEUDO_REGISTER;
- bzero (reg_known_equiv_p+FIRST_PSEUDO_REGISTER,
- (maxreg-FIRST_PSEUDO_REGISTER) * sizeof (char));
+ bzero (reg_known_equiv_p + FIRST_PSEUDO_REGISTER,
+ (maxreg - FIRST_PSEUDO_REGISTER) * sizeof (char));
/* Fill in the entries with known constant values. */
for (insn = get_insns (); insn; insn = NEXT_INSN (insn))
static void
clear_units ()
{
- bzero (unit_last_insn, sizeof (unit_last_insn));
- bzero (unit_tick, sizeof (unit_tick));
- bzero (unit_n_insns, sizeof (unit_n_insns));
+ 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));
}
/* Record an insn as one that will use the units encoded by UNIT. */
i = max_reg_num ();
reg_last_uses = (rtx *) alloca (i * sizeof (rtx));
- bzero (reg_last_uses, i * sizeof (rtx));
+ bzero ((char *) reg_last_uses, i * sizeof (rtx));
reg_last_sets = (rtx *) alloca (i * sizeof (rtx));
- bzero (reg_last_sets, i * sizeof (rtx));
+ bzero ((char *) reg_last_sets, i * sizeof (rtx));
reg_pending_sets = (regset) alloca (regset_bytes);
- bzero (reg_pending_sets, regset_bytes);
+ bzero ((char *) reg_pending_sets, regset_bytes);
reg_pending_sets_all = 0;
clear_units ();
if (reload_completed == 0)
{
- bcopy (basic_block_live_at_start[b], bb_live_regs, regset_bytes);
- bzero (bb_dead_regs, regset_bytes);
+ bcopy ((char *) basic_block_live_at_start[b], (char *) bb_live_regs,
+ regset_bytes);
+ bzero ((char *) bb_dead_regs, regset_bytes);
if (b == 0)
{
/* Q_SIZE will always be zero here. */
q_ptr = 0; clock = 0;
- bzero (insn_queue, sizeof (insn_queue));
+ bzero ((char *) insn_queue, sizeof (insn_queue));
/* Now, perform list scheduling. */
sched_reg_live_length = (int *) alloca (max_regno * sizeof (int));
bb_dead_regs = (regset) alloca (regset_bytes);
bb_live_regs = (regset) alloca (regset_bytes);
- bzero (sched_reg_n_calls_crossed, max_regno * sizeof (int));
- bzero (sched_reg_live_length, max_regno * sizeof (int));
- bcopy (reg_n_deaths, sched_reg_n_deaths, max_regno * sizeof (short));
+ bzero ((char *) sched_reg_n_calls_crossed, max_regno * sizeof (int));
+ bzero ((char *) sched_reg_live_length, max_regno * sizeof (int));
+ bcopy ((char *) reg_n_deaths, (char *) sched_reg_n_deaths,
+ max_regno * sizeof (short));
init_alias_analysis ();
}
else
rtx line;
line_note = (rtx *) alloca (max_uid * sizeof (rtx));
- bzero (line_note, max_uid * sizeof (rtx));
+ bzero ((char *) line_note, max_uid * sizeof (rtx));
line_note_head = (rtx *) alloca (n_basic_blocks * sizeof (rtx));
- bzero (line_note_head, n_basic_blocks * sizeof (rtx));
+ bzero ((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
}
}
- bzero (insn_luid, max_uid * sizeof (int));
- bzero (insn_priority, max_uid * sizeof (int));
- bzero (insn_tick, max_uid * sizeof (int));
- bzero (insn_costs, max_uid * sizeof (short));
- bzero (insn_units, max_uid * sizeof (short));
- bzero (insn_blockage, max_uid * sizeof (unsigned int));
- bzero (insn_ref_count, max_uid * sizeof (int));
+ 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));
/* Schedule each basic block, block by block. */
ncases = TREE_INT_CST_LOW (range) + 1;
labelvec = (rtx *) alloca (ncases * sizeof (rtx));
- bzero (labelvec, ncases * sizeof (rtx));
+ bzero ((char *) labelvec, ncases * sizeof (rtx));
for (n = thiscase->data.case_stmt.case_list; n; n = n->right)
{
if (cost_table == NULL)
{
cost_table = ((short *) xmalloc (129 * sizeof (short))) + 1;
- bzero (cost_table - 1, 129 * sizeof (short));
+ bzero ((char *) (cost_table - 1), 129 * sizeof (short));
for (i = 0; i < 128; i++)
{
/* Allocate tables to record info about regs. */
reg_where_dead = (int *) alloca (nregs * sizeof (int));
- bzero (reg_where_dead, nregs * sizeof (int));
+ bzero ((char *) reg_where_dead, nregs * sizeof (int));
reg_where_born = (int *) alloca (nregs * sizeof (int));
- bzero (reg_where_born, nregs * sizeof (int));
+ bzero ((char *) reg_where_born, nregs * sizeof (int));
reg_order = (int *) alloca (nregs * sizeof (int));
- bzero (reg_order, nregs * sizeof (int));
+ bzero ((char *) reg_order, nregs * sizeof (int));
reg_renumber = (short *) oballoc (nregs * sizeof (short));
for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
after_insn_hard_regs
= (HARD_REG_SET *) alloca (max_suid * sizeof (HARD_REG_SET));
- bzero (after_insn_hard_regs, max_suid * sizeof (HARD_REG_SET));
+ bzero ((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. */
{
float_handled = (handler != 0);
if (handler)
- bcopy (handler, float_handler, sizeof (float_handler));
+ bcopy ((char *) handler, (char *) float_handler, sizeof (float_handler));
}
/* Specify, in HANDLER, where to longjmp to when a floating arithmetic
float_handled = 1;
if (was_handled)
- bcopy (float_handler, old_handler, sizeof (float_handler));
- bcopy (handler, float_handler, sizeof (float_handler));
+ bcopy ((char *) float_handler, (char *) old_handler,
+ sizeof (float_handler));
+
+ bcopy ((char *) handler, (char *) float_handler, sizeof (float_handler));
return was_handled;
}
{
float_handled = handled;
if (handled)
- bcopy (handler, float_handler, sizeof (float_handler));
+ bcopy ((char *) handler, (char *) float_handler, sizeof (float_handler));
}
/* Signals actually come here. */
#ifndef VMS
if (flag_print_mem)
{
+#ifdef __alpha
+ char *sbrk ();
+#endif
char *lim = (char *) sbrk (0);
fprintf (stderr, "Data size %d.\n",
rtl_obstack = saveable_obstack = &permanent_obstack;
/* Init the hash table of identifiers. */
- bzero (hash_table, sizeof hash_table);
+ bzero ((char *) hash_table, sizeof hash_table);
}
void
tree_code_type = (char **) xmalloc (sizeof (standard_tree_code_type));
tree_code_length = (int *) xmalloc (sizeof (standard_tree_code_length));
tree_code_name = (char **) xmalloc (sizeof (standard_tree_code_name));
- bcopy (standard_tree_code_type, tree_code_type,
+ bcopy ((char *) standard_tree_code_type, (char *) tree_code_type,
sizeof (standard_tree_code_type));
- bcopy (standard_tree_code_length, tree_code_length,
+ bcopy ((char *) standard_tree_code_length, (char *) tree_code_length,
sizeof (standard_tree_code_length));
- bcopy (standard_tree_code_name, tree_code_name,
+ bcopy ((char *) standard_tree_code_name, (char *) tree_code_name,
sizeof (standard_tree_code_name));
}
to access the splittable_regs[] and addr_combined_regs[] arrays. */
splittable_regs = (rtx *) alloca (maxregnum * sizeof (rtx));
- bzero (splittable_regs, maxregnum * sizeof (rtx));
+ bzero ((char *) splittable_regs, maxregnum * sizeof (rtx));
splittable_regs_updates = (int *) alloca (maxregnum * sizeof (int));
- bzero (splittable_regs_updates, maxregnum * sizeof (int));
+ bzero ((char *) splittable_regs_updates, maxregnum * sizeof (int));
addr_combined_regs
= (struct induction **) alloca (maxregnum * sizeof (struct induction *));
- bzero (addr_combined_regs, maxregnum * sizeof (struct induction *));
+ bzero ((char *) addr_combined_regs, maxregnum * sizeof (struct induction *));
/* If this loop requires exit tests when unrolled, check to see if we
can precondition the loop so as to make the exit tests unnecessary.
emit_label_after (labels[unroll_number - i],
PREV_INSN (loop_start));
- bzero (map->insn_map, max_insnno * sizeof (rtx));
- bzero (map->const_equiv_map, maxregnum * sizeof (rtx));
- bzero (map->const_age_map, maxregnum * sizeof (unsigned));
+ bzero ((char *) map->insn_map, max_insnno * sizeof (rtx));
+ bzero ((char *) map->const_equiv_map, maxregnum * sizeof (rtx));
+ bzero ((char *) map->const_age_map,
+ maxregnum * sizeof (unsigned));
map->const_age = 0;
for (j = 0; j < max_labelno; j++)
for (i = 0; i < unroll_number; i++)
{
- bzero (map->insn_map, max_insnno * sizeof (rtx));
- bzero (map->const_equiv_map, new_maxregnum * sizeof (rtx));
- bzero (map->const_age_map, new_maxregnum * sizeof (unsigned));
+ 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));
map->const_age = 0;
for (j = 0; j < max_labelno; j++)
{
error ("floating point trap outputting a constant");
#ifdef REAL_IS_NOT_DOUBLE
- bzero (&d, sizeof d);
+ bzero ((char *) &d, sizeof d);
d = dconst0;
#else
d = 0;
/* Detect special cases. */
/* Avoid REAL_VALUES_EQUAL here in order to distinguish minus zero. */
- if (!bcmp (&dconst0, &d, sizeof d))
+ if (!bcmp ((char *) &dconst0, (char *) &d, sizeof d))
return CONST0_RTX (mode);
/* Check for NaN first, because some ports (specifically the i386) do not
emit correct ieee-fp code by default, and thus will generate a core
If one is found, return it. */
for (r = const_double_chain; r; r = CONST_DOUBLE_CHAIN (r))
- if (! bcmp (&CONST_DOUBLE_LOW (r), &u, sizeof u)
+ if (! bcmp ((char *) &CONST_DOUBLE_LOW (r), (char *) &u, sizeof u)
&& GET_MODE (r) == mode)
return r;
rtl_in_saveable_obstack ();
r = rtx_alloc (CONST_DOUBLE);
PUT_MODE (r, mode);
- bcopy (&u, &CONST_DOUBLE_LOW (r), sizeof u);
+ bcopy ((char *) &u, (char *) &CONST_DOUBLE_LOW (r), sizeof u);
pop_obstacks ();
/* Don't touch const_double_chain in nested function; see force_const_mem.
return 0;
strp = TREE_STRING_POINTER (exp);
len = TREE_STRING_LENGTH (exp);
- if (bcmp (&TREE_STRING_LENGTH (exp), p,
+ if (bcmp ((char *) &TREE_STRING_LENGTH (exp), p,
sizeof TREE_STRING_LENGTH (exp)))
return 0;
p += sizeof TREE_STRING_LENGTH (exp);
int length = list_length (CONSTRUCTOR_ELTS (exp));
tree type;
- if (bcmp (&length, p, sizeof length))
+ if (bcmp ((char *) &length, p, sizeof length))
return 0;
p += sizeof length;
type = TREE_TYPE (exp);
else
type = 0;
- if (bcmp (&type, p, sizeof type))
+ if (bcmp ((char *) &type, p, sizeof type))
return 0;
p += sizeof type;
if (TREE_CODE (TREE_TYPE (exp)) == ARRAY_TYPE)
{
int size = int_size_in_bytes (TREE_TYPE (exp));
- if (bcmp (&size, p, sizeof size))
+ if (bcmp ((char *) &size, p, sizeof size))
return 0;
p += sizeof size;
}
{
tree zero = 0;
- if (bcmp (&zero, p, sizeof zero))
+ if (bcmp ((char *) &zero, p, sizeof zero))
return 0;
p += sizeof zero;
}
const_rtx_sym_hash_table
= ((struct pool_sym **)
oballoc (MAX_RTX_HASH_TABLE * sizeof (struct pool_sym *)));
- bzero (const_rtx_hash_table,
+ bzero ((char *) const_rtx_hash_table,
MAX_RTX_HASH_TABLE * sizeof (struct constant_descriptor *));
- bzero (const_rtx_sym_hash_table,
+ bzero ((char *) const_rtx_sym_hash_table,
MAX_RTX_HASH_TABLE * sizeof (struct pool_sym *));
first_pool = last_pool = 0;
value->kind = RTX_DOUBLE;
if (GET_MODE (x) != VOIDmode)
value->mode = GET_MODE (x);
- bcopy (&CONST_DOUBLE_LOW (x), &value->un.du, sizeof value->un.du);
+ bcopy ((char *) &CONST_DOUBLE_LOW (x),
+ (char *) &value->un.du, sizeof value->un.du);
break;
case CONST_INT:
if (GET_CODE (x) != CONST_DOUBLE)
abort ();
- bcopy (&CONST_DOUBLE_LOW (x), &u, sizeof u);
+ bcopy ((char *) &CONST_DOUBLE_LOW (x), (char *) &u, sizeof u);
assemble_real (u.d, pool->mode);
break;
OSDN Git Service
