Cast pointer operands to bzero, bcopy, and bcmp to (char *).

From-SVN: r7472

31 files changed, 341 insertions, 279 deletions

diff --git a/gcc/bc-emit.c b/gcc/bc-emit.c
index e363f2a..b5d0c6c 100644
--- a/gcc/bc-emit.c
+++ b/gcc/bc-emit.c
@@ -361,7 +361,7 @@ bc_seg_write (seg, file)
 	  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);
@@ -603,7 +603,7 @@ bc_end_function ()
     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. */
diff --git a/gcc/calls.c b/gcc/calls.c
index 88ab443..d3b21a9 100644
--- a/gcc/calls.c
+++ b/gcc/calls.c
@@ -949,7 +949,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 (args, num_actuals * sizeof (struct arg_data));
+  bzero ((char *) args, num_actuals * sizeof (struct arg_data));
 
   args_size.constant = 0;
   args_size.var = 0;
diff --git a/gcc/cccp.c b/gcc/cccp.c
index bce1c9b..39b9a17 100644
--- a/gcc/cccp.c
+++ b/gcc/cccp.c
@@ -1157,11 +1157,11 @@ main (argc, argv)
   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.  */
 
@@ -1790,7 +1790,8 @@ main (argc, argv)
 	  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));
     }
   }
@@ -2229,17 +2230,19 @@ trigraph_pcp (buf)
       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)
@@ -2538,7 +2541,7 @@ do { ip = &instack[indepth];		\
 	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;
 	}
@@ -2753,7 +2756,7 @@ do { ip = &instack[indepth];		\
 	  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;
@@ -2789,14 +2792,14 @@ do { ip = &instack[indepth];		\
 	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;
 	  }
 
@@ -2854,7 +2857,7 @@ do { ip = &instack[indepth];		\
 	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;
 	  }
 	}
@@ -3616,7 +3619,7 @@ handle_directive (ip, op)
 	/* 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)
@@ -3735,14 +3738,14 @@ handle_directive (ip, op)
 	/* 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;
@@ -3957,7 +3960,7 @@ oops:
   }
   len = strlen (buf);
   check_expand (op, len);
-  bcopy (buf, op->bufp, len);
+  bcopy (buf, (char *) op->bufp, len);
   op->bufp += len;
 
   return;
@@ -4131,7 +4134,7 @@ get_filename:
     } 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++;
@@ -4351,7 +4354,8 @@ get_filename:
 	    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);
@@ -4672,7 +4676,7 @@ finclude (f, fname, op, system_header_p, dirptr)
     }
 
   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;
@@ -4845,7 +4849,7 @@ lookup_import (filename, searchptr)
     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 */
@@ -4872,7 +4876,7 @@ add_import (fd, fname)
   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;
@@ -5193,11 +5197,11 @@ pass_thru_directive (buf, limit, op, keyword)
 
   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';
@@ -5425,7 +5429,7 @@ do_define (buf, limit, op, keyword)
 
 	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)
@@ -5471,7 +5475,7 @@ check_macro_name (symname, usage)
   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 {
@@ -6124,7 +6128,7 @@ read_token_list (bpp, limit, error_flag)
 
     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;
@@ -6457,7 +6461,7 @@ do_error (buf, limit, op, keyword)
 {
   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);
@@ -6478,7 +6482,7 @@ do_warning (buf, limit, op, keyword)
 {
   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);
@@ -6530,19 +6534,19 @@ do_ident (buf, limit)
 
   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;
@@ -6803,7 +6807,7 @@ do_xifdef (buf, limit, op, keyword)
     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;
     }
   }
@@ -7551,7 +7555,7 @@ output_line_command (ip, op, conditional, file_change)
   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;
 }
@@ -7881,7 +7885,7 @@ macroexpand (hp, op)
 	    }
 	  }
 
-	  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.
@@ -7896,7 +7900,8 @@ macroexpand (hp, op)
 	    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';
@@ -8016,7 +8021,7 @@ macarg (argptr, rest_args)
     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;
 
@@ -8037,7 +8042,8 @@ macarg (argptr, rest_args)
       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;
     }
diff --git a/gcc/collect2.c b/gcc/collect2.c
index ff83c9d..b230199 100644
--- a/gcc/collect2.c
+++ b/gcc/collect2.c
@@ -552,7 +552,9 @@ putenv (str)
   /* 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 */
 }
@@ -1828,7 +1830,7 @@ scan_prog_file (prog_name, which_pass)
       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.  */
@@ -2013,7 +2015,7 @@ scan_prog_file (prog_name, which_pass)
 	  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;
 	}
     }
diff --git a/gcc/combine.c b/gcc/combine.c
index b70195a..ff902e4 100644
--- a/gcc/combine.c
+++ b/gcc/combine.c
@@ -465,7 +465,7 @@ combine_instructions (f, nregs)
     = (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));
@@ -658,14 +658,14 @@ init_reg_last_arrays ()
 {
   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));
 }
 
@@ -1629,7 +1629,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 (&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
diff --git a/gcc/cse.c b/gcc/cse.c
index eb541ae..514798f 100644
--- a/gcc/cse.c
+++ b/gcc/cse.c
@@ -763,10 +763,11 @@ new_basic_block ()
 
   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
@@ -782,7 +783,7 @@ new_basic_block ()
 	}
     }
 
-  bzero (table, sizeof table);
+  bzero ((char *) table, sizeof table);
 
   prev_insn = 0;
 
@@ -4092,7 +4093,7 @@ simplify_plus_minus (code, mode, op0, op1)
   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
@@ -7989,7 +7990,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 (table, sizeof table);
+  bzero ((char *) table, sizeof table);
   free_element_chain = 0;
   n_elements_made = 0;
 
@@ -7997,7 +7998,7 @@ cse_main (f, nregs, after_loop, file)
 
   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,
@@ -8418,7 +8419,7 @@ delete_dead_from_cse (insns, nreg)
   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);
 
diff --git a/gcc/dbxout.c b/gcc/dbxout.c
index efcdaa6..5418566 100644
--- a/gcc/dbxout.c
+++ b/gcc/dbxout.c
@@ -399,7 +399,7 @@ dbxout_init (asm_file, input_file_name, syms)
 
   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
@@ -940,8 +940,10 @@ dbxout_type (type, full, show_arg_types)
 
       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;
 	}
     }
diff --git a/gcc/emit-rtl.c b/gcc/emit-rtl.c
index 32e7fb5..3afcccb 100644
--- a/gcc/emit-rtl.c
+++ b/gcc/emit-rtl.c
@@ -501,8 +501,9 @@ gen_reg_rtx (mode)
       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;
 
@@ -1523,8 +1524,9 @@ copy_rtx_if_shared (orig)
       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;
     }
@@ -3087,8 +3089,9 @@ restore_reg_data_1 (orig)
 		  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;
@@ -3166,7 +3169,7 @@ init_emit ()
 
   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;
@@ -3257,10 +3260,10 @@ init_emit_once (line_numbers)
 	  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);
 
diff --git a/gcc/expmed.c b/gcc/expmed.c
index 09cbbaf..c0fe5f7 100644
--- a/gcc/expmed.c
+++ b/gcc/expmed.c
@@ -2116,8 +2116,10 @@ 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 (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);
 }
 
 /* Perform a multiplication and return an rtx for the result.
diff --git a/gcc/flow.c b/gcc/flow.c
index 448608c..ae97677 100644
--- a/gcc/flow.c
+++ b/gcc/flow.c
@@ -808,29 +808,36 @@ life_analysis (f, nregs)
   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.
@@ -1035,10 +1042,10 @@ life_analysis (f, nregs)
 	    {
 	      /* 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]
@@ -1168,31 +1175,33 @@ allocate_for_life_analysis ()
   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,
@@ -1294,7 +1303,7 @@ propagate_block (old, first, last, final, significant, bnum)
 
       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));
 
diff --git a/gcc/fold-const.c b/gcc/fold-const.c
index c3f2c5c..c520514 100644
--- a/gcc/fold-const.c
+++ b/gcc/fold-const.c
@@ -339,7 +339,7 @@ mul_double (l1, h1, l2, h2, lv, hv)
   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++)
@@ -595,10 +595,10 @@ div_and_round_double (code, uns,
       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);
@@ -1837,7 +1837,8 @@ operand_equal_p (arg0, arg1, only_const)
   /* 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)
diff --git a/gcc/function.c b/gcc/function.c
index 8d91cb7..4b9e33c 100644
--- a/gcc/function.c
+++ b/gcc/function.c
@@ -3085,7 +3085,7 @@ assign_parms (fndecl, second_time)
     }
 			       
   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);
@@ -3569,8 +3569,9 @@ assign_parms (fndecl, second_time)
 
 	      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;
 	    }
diff --git a/gcc/gcc.c b/gcc/gcc.c
index 57e9bde..56b99ed 100644
--- a/gcc/gcc.c
+++ b/gcc/gcc.c
@@ -1031,11 +1031,12 @@ read_specs (filename)
 	    = ((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)
@@ -1526,7 +1527,8 @@ putenv (str)
   /* 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 */
 }
@@ -3951,7 +3953,8 @@ main (argc, argv)
      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.  */
@@ -4054,7 +4057,7 @@ main (argc, argv)
      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.  */
 
@@ -4262,8 +4265,8 @@ lookup_compiler (name, length, language)
 	      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.  */
diff --git a/gcc/genattrtab.c b/gcc/genattrtab.c
index bacdafb..cd5ae43 100644
--- a/gcc/genattrtab.c
+++ b/gcc/genattrtab.c
@@ -1883,7 +1883,7 @@ expand_units ()
 	    * 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
@@ -2425,7 +2425,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 (&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)
@@ -2517,7 +2517,8 @@ simplify_cond (exp, insn_code, insn_index)
       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;
     }
@@ -3301,8 +3302,9 @@ optimize_attrs ()
   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;
 
@@ -5436,7 +5438,7 @@ copy_rtx_unchanging (orig)
   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
diff --git a/gcc/global.c b/gcc/global.c
index 6d6ac47..c3dc749 100644
--- a/gcc/global.c
+++ b/gcc/global.c
@@ -364,7 +364,7 @@ global_alloc (file)
   /* 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));
@@ -400,10 +400,10 @@ global_alloc (file)
   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)
@@ -420,8 +420,8 @@ global_alloc (file)
   /* Calculate amount of usage of each hard reg by pseudos
      allocated by local-alloc.  This is to see if we want to
      override it.  */
-  bzero (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)
       {
@@ -446,30 +446,32 @@ global_alloc (file)
 
   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));
 
@@ -604,7 +606,7 @@ global_conflicts ()
 
   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.
diff --git a/gcc/integrate.c b/gcc/integrate.c
index 0d03ba8..bf0c285 100644
--- a/gcc/integrate.c
+++ b/gcc/integrate.c
@@ -242,7 +242,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 (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;
@@ -465,8 +465,8 @@ save_for_inline_copying (fndecl)
     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.  */
@@ -480,7 +480,7 @@ save_for_inline_copying (fndecl)
   /* 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 ();
@@ -1060,8 +1060,9 @@ copy_for_inline (orig)
   /* 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
@@ -1306,13 +1307,13 @@ expand_inline_function (fndecl, parms, target, ignore, type, structure_value_add
   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);
 
@@ -1335,11 +1336,13 @@ expand_inline_function (fndecl, parms, target, ignore, type, structure_value_add
 
   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
diff --git a/gcc/jump.c b/gcc/jump.c
index 08130db..b8eaf11 100644
--- a/gcc/jump.c
+++ b/gcc/jump.c
@@ -197,7 +197,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 (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.
@@ -2082,7 +2082,7 @@ duplicate_loop_exit_test (loop_start)
 	    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;
@@ -4052,7 +4052,8 @@ thread_jumps (f, max_reg, flag_before_loop)
 	  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);
diff --git a/gcc/local-alloc.c b/gcc/local-alloc.c
index a408719..3b2d81e 100644
--- a/gcc/local-alloc.c
+++ b/gcc/local-alloc.c
@@ -415,13 +415,14 @@ local_alloc ()
 
   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));
@@ -430,10 +431,13 @@ local_alloc ()
   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));
@@ -492,7 +496,7 @@ local_alloc ()
       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);
@@ -937,8 +941,8 @@ update_equiv_regs ()
   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 ();
 
@@ -1139,7 +1143,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 (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.  */
 
diff --git a/gcc/loop.c b/gcc/loop.c
index 624329b..6469707 100644
--- a/gcc/loop.c
+++ b/gcc/loop.c
@@ -361,8 +361,8 @@ loop_optimize (f, dumpfile)
   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.  */
@@ -573,13 +573,13 @@ scan_loop (loop_start, end, nregs)
      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,
@@ -587,7 +587,7 @@ scan_loop (loop_start, end, nregs)
 
   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)
     {
@@ -1535,7 +1535,7 @@ move_movables (movables, threshold, insn_count, loop_start, end, nregs)
   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;
 
@@ -2917,7 +2917,7 @@ count_loop_regs_set (from, to, may_not_move, single_usage, count_ptr, nregs)
   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')
@@ -3004,8 +3004,9 @@ 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 (last_set, nregs * sizeof (rtx));
+	bzero ((char *) last_set, nregs * sizeof (rtx));
     }
   *count_ptr = count;
 }
diff --git a/gcc/print-tree.c b/gcc/print-tree.c
index 9c8fbcc..f4f878f 100644
--- a/gcc/print-tree.c
+++ b/gcc/print-tree.c
@@ -51,8 +51,9 @@ debug_tree (node)
      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);
diff --git a/gcc/real.h b/gcc/real.h
index 5d66861..34d6d67 100644
--- a/gcc/real.h
+++ b/gcc/real.h
@@ -417,7 +417,7 @@ REAL_VALUE_TYPE real_value_from_int_cst ();
 
 #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.  */
diff --git a/gcc/regclass.c b/gcc/regclass.c
index bef30ab..d4636d5 100644
--- a/gcc/regclass.c
+++ b/gcc/regclass.c
@@ -219,7 +219,7 @@ init_reg_sets ()
 
   /* 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))
@@ -702,7 +702,7 @@ regclass (f, nregs)
     {
       /* 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);
@@ -1662,10 +1662,11 @@ reg_scan (f, nregs, repeat)
 	= (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;
 
diff --git a/gcc/reload.c b/gcc/reload.c
index 7452b2a..6aabcf2 100644
--- a/gcc/reload.c
+++ b/gcc/reload.c
@@ -671,7 +671,7 @@ get_secondary_mem (x, mode, opnum, type)
 void
 clear_secondary_mem ()
 {
-  bzero (secondary_memlocs, sizeof secondary_memlocs);
+  bzero ((char *) secondary_memlocs, sizeof secondary_memlocs);
 }
 #endif /* SECONDARY_MEMORY_NEEDED */
 
@@ -2180,7 +2180,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 (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.
@@ -2231,7 +2231,8 @@ find_reloads (insn, replace, ind_levels, live_known, reload_reg_p)
 			       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)
@@ -3186,7 +3187,8 @@ 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 (constraints1, constraints, noperands * sizeof (char *));
+	  bcopy ((char *) constraints1, (char *) constraints,
+		 noperands * sizeof (char *));
 	  goto try_swapped;
 	}
       else
diff --git a/gcc/reload1.c b/gcc/reload1.c
index d32e91f..98b779f 100644
--- a/gcc/reload1.c
+++ b/gcc/reload1.c
@@ -479,8 +479,8 @@ reload (first, global, dumpfile)
   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.  */
@@ -513,17 +513,17 @@ reload (first, global, dumpfile)
      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);
 
@@ -711,7 +711,7 @@ reload (first, global, dumpfile)
   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);
       }
 
@@ -763,13 +763,13 @@ reload (first, global, dumpfile)
       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;
 
@@ -802,7 +802,7 @@ reload (first, global, dumpfile)
 
       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
@@ -1020,7 +1020,7 @@ reload (first, global, dumpfile)
 		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.  */
@@ -3060,9 +3060,9 @@ eliminate_regs (x, mem_mode, insn)
 	  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;
 	    }
@@ -3081,9 +3081,10 @@ eliminate_regs (x, mem_mode, insn)
 		  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;
 		    }
@@ -3640,10 +3641,10 @@ reload_as_needed (first, live_known)
   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++)
     {
@@ -4817,8 +4818,8 @@ choose_reload_regs (insn, avoid_return_reg)
   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);
@@ -4939,13 +4940,15 @@ choose_reload_regs (insn, avoid_return_reg)
   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);
@@ -5312,13 +5315,16 @@ choose_reload_regs (insn, avoid_return_reg)
       /* 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);
diff --git a/gcc/sched.c b/gcc/sched.c
index 3e78044..9870967 100644
--- a/gcc/sched.c
+++ b/gcc/sched.c
@@ -407,14 +407,14 @@ init_alias_analysis ()
   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))
@@ -1170,9 +1170,9 @@ static int unit_n_insns[FUNCTION_UNITS_SIZE];
 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.  */
@@ -3088,11 +3088,11 @@ schedule_block (b, file)
 
   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 ();
 
@@ -3327,8 +3327,9 @@ schedule_block (b, file)
 
   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)
 	{
@@ -3568,7 +3569,7 @@ schedule_block (b, file)
 
   /* 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.  */
 
@@ -4627,9 +4628,10 @@ schedule_insns (dump_file)
       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
@@ -4648,9 +4650,9 @@ schedule_insns (dump_file)
       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
@@ -4666,13 +4668,13 @@ schedule_insns (dump_file)
 	    }
     }
 
-  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.  */
 
diff --git a/gcc/stmt.c b/gcc/stmt.c
index 704dc65..acaa436 100644
--- a/gcc/stmt.c
+++ b/gcc/stmt.c
@@ -4527,7 +4527,7 @@ expand_end_case (orig_index)
 
 	  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)
 	    {
@@ -4756,7 +4756,7 @@ estimate_case_costs (node)
   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++)
 	{
diff --git a/gcc/stupid.c b/gcc/stupid.c
index 1293d5d..7ceec9f 100644
--- a/gcc/stupid.c
+++ b/gcc/stupid.c
@@ -149,13 +149,13 @@ stupid_life_analysis (f, nregs, file)
   /* 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++)
@@ -167,7 +167,7 @@ stupid_life_analysis (f, nregs, file)
   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.  */
diff --git a/gcc/toplev.c b/gcc/toplev.c
index 0cdc520..2cd7943 100644
--- a/gcc/toplev.c
+++ b/gcc/toplev.c
@@ -1798,7 +1798,7 @@ set_float_handler (handler)
 {
   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
@@ -1813,8 +1813,10 @@ push_float_handler (handler, old_handler)
 
   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;
 }
 
@@ -1828,7 +1830,7 @@ pop_float_handler (handled, handler)
 {
   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.  */
@@ -3877,6 +3879,9 @@ You Lose!  You must define PREFERRED_DEBUGGING_TYPE!
 #ifndef VMS
   if (flag_print_mem)
     {
+#ifdef __alpha
+      char *sbrk ();
+#endif
       char *lim = (char *) sbrk (0);
 
       fprintf (stderr, "Data size %d.\n",
diff --git a/gcc/tree.c b/gcc/tree.c
index 1839b31..e0aa0ae 100644
--- a/gcc/tree.c
+++ b/gcc/tree.c
@@ -292,7 +292,7 @@ init_obstacks ()
   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
@@ -812,11 +812,11 @@ init_tree_codes ()
   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));
 }
 
diff --git a/gcc/unroll.c b/gcc/unroll.c
index aba78dc..3f628bd 100644
--- a/gcc/unroll.c
+++ b/gcc/unroll.c
@@ -705,12 +705,12 @@ 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 (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.
@@ -913,9 +913,10 @@ unroll_loop (loop_end, insn_count, loop_start, end_insert_before,
 	      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++)
@@ -1050,9 +1051,9 @@ unroll_loop (loop_end, insn_count, loop_start, end_insert_before,
 
   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++)
diff --git a/gcc/varasm.c b/gcc/varasm.c
index da90a0c..ebf8ded 100644
--- a/gcc/varasm.c
+++ b/gcc/varasm.c
@@ -1694,7 +1694,7 @@ assemble_real (d, mode)
     {
       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;
@@ -1885,7 +1885,7 @@ immed_real_const_1 (d, mode)
   /* 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
@@ -1905,7 +1905,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 (&CONST_DOUBLE_LOW (r), &u, sizeof u)
+    if (! bcmp ((char *) &CONST_DOUBLE_LOW (r), (char *) &u, sizeof u)
 	&& GET_MODE (r) == mode)
       return r;
 
@@ -1921,7 +1921,7 @@ immed_real_const_1 (d, mode)
   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.
@@ -2214,7 +2214,7 @@ compare_constant_1 (exp, p)
 	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);
@@ -2232,7 +2232,7 @@ compare_constant_1 (exp, p)
       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;
 
@@ -2242,7 +2242,7 @@ compare_constant_1 (exp, p)
 	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;
 
@@ -2250,7 +2250,7 @@ compare_constant_1 (exp, p)
       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;
 	}
@@ -2266,7 +2266,7 @@ compare_constant_1 (exp, p)
 	    {
 	      tree zero = 0;
 
-	      if (bcmp (&zero, p, sizeof zero))
+	      if (bcmp ((char *) &zero, p, sizeof zero))
 		return 0;
 	      p += sizeof zero;
 	    }
@@ -2774,9 +2774,9 @@ init_const_rtx_hash_table ()
   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;
@@ -2852,7 +2852,8 @@ decode_rtx_const (mode, x, value)
       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:
@@ -3226,7 +3227,7 @@ output_constant_pool (fnname, fndecl)
 	  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;