* alpha.c (check_float_value): Use memcpy, not bcopy.

	* arm.c (output_move_double): Likewise.
	* arm.md: Likewise.
	* m88k.c (legitimize_operand): Likewise.
	* m88k.h (ORDER_REGS_FOR_LOCAL_ALLOC): Likewise.
	* m88k.md: Likewise.
	* mips.c (override_options): Likewise.
	* mips.md: Likewise.
	* romp.c (output_fpops): Likewise.
	* rs6000.c (rs6000_override_options): Likewise.
	* sh.md: Likewise.
	* vax.c (check_float_value): Likewise.

	* emit-rtl.c (copy_rtx_if_shared, init_emit_once): Likewise.
	* expmed.c (synth_mult): Likewise.
	* final.c (add_bb_string): Likewise.
	* genattr.c (main): Likewise.
	* genattrtab.c (attr_string, simplify_cond, copy_rtx_unchanging):
	Likewise.
	* jump.c (thread_jumps): Likewise.
	* prefix.c (save_string): Likewise.
	* real.h (REAL_VALUE_FROM_CONST_DOUBLE): Likewise.
	* regclass.c (init_reg_sets, init_reg_sets_1): Likewise.
	* reload1.c (reload, eliminate_regs): Likewise.

cp:
	* decl.c (grokdeclarator, save_function_data): Use memcpy, not bcopy.
	* lex.c (copy_lang_decl): Likewise.

java:
	* decl.c (copy_lang_decl): Use memcpy, not bcopy.
	* jcf-parse.c (jcf_figure_file_type): Likewise.


git-svn-id: svn+ssh://gcc.gnu.org/svn/gcc/trunk@37367 138bc75d-0d04-0410-961f-82ee72b054a4

29 files changed, 85 insertions, 58 deletions

diff --git a/gcc/ChangeLog b/gcc/ChangeLog
index 6d995eaa728..896a2dd6a62 100644
--- a/gcc/ChangeLog
+++ b/gcc/ChangeLog
@@ -1,3 +1,30 @@
+2000-11-10  Kaveh R. Ghazi  <ghazi@caip.rutgers.edu>
+
+	* alpha.c (check_float_value): Use memcpy, not bcopy.
+	* arm.c (output_move_double): Likewise.
+	* arm.md: Likewise.
+	* m88k.c (legitimize_operand): Likewise.
+	* m88k.h (ORDER_REGS_FOR_LOCAL_ALLOC): Likewise.
+	* m88k.md: Likewise.
+	* mips.c (override_options): Likewise.
+	* mips.md: Likewise.
+	* romp.c (output_fpops): Likewise.
+	* rs6000.c (rs6000_override_options): Likewise.
+	* sh.md: Likewise.
+	* vax.c (check_float_value): Likewise.
+
+	* emit-rtl.c (copy_rtx_if_shared, init_emit_once): Likewise.
+	* expmed.c (synth_mult): Likewise.
+	* final.c (add_bb_string): Likewise.
+	* genattr.c (main): Likewise.
+	* genattrtab.c (attr_string, simplify_cond, copy_rtx_unchanging):
+	Likewise.
+	* jump.c (thread_jumps): Likewise.
+	* prefix.c (save_string): Likewise.
+	* real.h (REAL_VALUE_FROM_CONST_DOUBLE): Likewise.
+	* regclass.c (init_reg_sets, init_reg_sets_1): Likewise.
+	* reload1.c (reload, eliminate_regs): Likewise.
+
 2000-11-10  Joseph S. Myers  <jsm28@cam.ac.uk>
 
 	* gcc.texi (Service): Update to reflect current practice and
diff --git a/gcc/config/alpha/alpha.c b/gcc/config/alpha/alpha.c
index a1d1b10b303..06c141f0318 100644
--- a/gcc/config/alpha/alpha.c
+++ b/gcc/config/alpha/alpha.c
@@ -6068,7 +6068,7 @@ check_float_value (mode, d, overflow)
       else
 	fvptr = &float_values[4];
 
-      bcopy ((char *) d, (char *) &r, sizeof (REAL_VALUE_TYPE));
+      memcpy (&r, d, sizeof (REAL_VALUE_TYPE));
       if (REAL_VALUES_LESS (fvptr[0], r))
 	{
 	  bcopy ((char *) &fvptr[0], (char *) d,
diff --git a/gcc/config/arm/arm.c b/gcc/config/arm/arm.c
index 854835d1932..7a04dd78ca9 100644
--- a/gcc/config/arm/arm.c
+++ b/gcc/config/arm/arm.c
@@ -6006,8 +6006,7 @@ output_move_double (operands)
 	      long l[2];
 	      union real_extract u;
 
-	      bcopy ((char *) &CONST_DOUBLE_LOW (operands[1]), (char *) &u,
-		     sizeof (u));
+	      memcpy (&u, &CONST_DOUBLE_LOW (operands[1]), sizeof (u));
 	      REAL_VALUE_TO_TARGET_DOUBLE (u.d, l);
 	      otherops[1] = GEN_INT (l[1]);
 	      operands[1] = GEN_INT (l[0]);
diff --git a/gcc/config/arm/arm.md b/gcc/config/arm/arm.md
index 1c0f0cd29f8..a4d7b803321 100644
--- a/gcc/config/arm/arm.md
+++ b/gcc/config/arm/arm.md
@@ -8907,8 +8907,7 @@
       case MODE_FLOAT:
       {
         union real_extract u;
-        bcopy ((char *) &CONST_DOUBLE_LOW (operands[0]), (char *) &u,
-					   sizeof u);
+        memcpy (&u, &CONST_DOUBLE_LOW (operands[0]), sizeof u);
         assemble_real (u.d, GET_MODE (operands[0]));
         break;
       }
@@ -8932,8 +8931,7 @@
        case MODE_FLOAT:
         {
           union real_extract u;
-          bcopy ((char *) &CONST_DOUBLE_LOW (operands[0]), (char *) &u,
-					     sizeof u);
+          memcpy (&u, &CONST_DOUBLE_LOW (operands[0]), sizeof u);
           assemble_real (u.d, GET_MODE (operands[0]));
           break;
         }
diff --git a/gcc/config/m88k/m88k.c b/gcc/config/m88k/m88k.c
index c4d2ab0885d..beeb8fcfeb7 100644
--- a/gcc/config/m88k/m88k.c
+++ b/gcc/config/m88k/m88k.c
@@ -1153,7 +1153,7 @@ legitimize_operand (op, mode)
 
   if (GET_CODE (op) == CONST_DOUBLE)
     {
-      bcopy (&CONST_DOUBLE_LOW (op), &u.r, sizeof u);
+      memcpy (&u.r, &CONST_DOUBLE_LOW (op), sizeof u);
       if (u.d.exponent != 0x7ff /* NaN */
 	  && u.d.mantissa2 == 0 /* Mantissa fits */
 	  && (u.s.exponent1 == 0x8 || u.s.exponent1 == 0x7) /* Exponent fits */
diff --git a/gcc/config/m88k/m88k.h b/gcc/config/m88k/m88k.h
index 36cf4d1d82a..59c0f59c499 100644
--- a/gcc/config/m88k/m88k.h
+++ b/gcc/config/m88k/m88k.h
@@ -693,8 +693,8 @@ extern int flag_pic;				/* -fpic */
   static int leaf[] = REG_LEAF_ALLOC_ORDER;			\
   static int nonleaf[] = REG_ALLOC_ORDER;			\
 								\
-  bcopy (regs_ever_live[1] ? nonleaf : leaf, reg_alloc_order,	\
-	 FIRST_PSEUDO_REGISTER * sizeof (int));			\
+  memcpy (reg_alloc_order, regs_ever_live[1] ? nonleaf : leaf,	\
+	  FIRST_PSEUDO_REGISTER * sizeof (int));		\
 }
 
 /*** Register Classes ***/
diff --git a/gcc/config/m88k/m88k.md b/gcc/config/m88k/m88k.md
index 222248fd17e..d8e7a738bcf 100644
--- a/gcc/config/m88k/m88k.md
+++ b/gcc/config/m88k/m88k.md
@@ -3054,7 +3054,7 @@
   if (real_power_of_2_operand (operands[2], DFmode))
     {
       union real_extract u;
-      bcopy (&CONST_DOUBLE_LOW (operands[2]), &u, sizeof u);
+      memcpy (&u, &CONST_DOUBLE_LOW (operands[2]), sizeof u);
       emit_insn (gen_muldf3 (operands[0], operands[1],
 			     CONST_DOUBLE_FROM_REAL_VALUE (1.0/u.d, DFmode)));
       DONE;
diff --git a/gcc/config/mips/mips.c b/gcc/config/mips/mips.c
index 13957fc2f7f..2f66d2a00d9 100644
--- a/gcc/config/mips/mips.c
+++ b/gcc/config/mips/mips.c
@@ -5022,8 +5022,7 @@ override_options ()
      reg_names points into via the REGISTER_NAMES macro.  */
 
   if (TARGET_NAME_REGS)
-    bcopy ((char *) mips_sw_reg_names, (char *) mips_reg_names,
-	   sizeof (mips_reg_names));
+    memcpy (mips_reg_names, mips_sw_reg_names, sizeof (mips_reg_names));
 
   /* When compiling for the mips16, we can not use floating point.  We
      record the original hard float value in mips16_hard_float.  */
diff --git a/gcc/config/mips/mips.md b/gcc/config/mips/mips.md
index cf93964a039..06d4c3842b4 100644
--- a/gcc/config/mips/mips.md
+++ b/gcc/config/mips/mips.md
@@ -10305,7 +10305,7 @@ ld\\t%2,%1-%S1(%2)\;daddu\\t%2,%2,$31\;j\\t%2"
 
   if (GET_CODE (operands[0]) != CONST_DOUBLE)
     abort ();
-  bcopy ((char *) &CONST_DOUBLE_LOW (operands[0]), (char *) &u, sizeof u);
+  memcpy (&u, &CONST_DOUBLE_LOW (operands[0]), sizeof u);
   assemble_real (u.d, SFmode);
   return \"\";
 }"
@@ -10322,7 +10322,7 @@ ld\\t%2,%1-%S1(%2)\;daddu\\t%2,%2,$31\;j\\t%2"
 
   if (GET_CODE (operands[0]) != CONST_DOUBLE)
     abort ();
-  bcopy ((char *) &CONST_DOUBLE_LOW (operands[0]), (char *) &u, sizeof u);
+  memcpy (&u, &CONST_DOUBLE_LOW (operands[0]), sizeof u);
   assemble_real (u.d, DFmode);
   return \"\";
 }"
diff --git a/gcc/config/romp/romp.c b/gcc/config/romp/romp.c
index 33e8e90bb7e..91cfeeba33b 100644
--- a/gcc/config/romp/romp.c
+++ b/gcc/config/romp/romp.c
@@ -1957,8 +1957,7 @@ output_fpops (file)
 		{
 		  union real_extract u;
 
-		  bcopy ((char *) &CONST_DOUBLE_LOW (immed[i]),
-			 (char *) &u, sizeof u);
+		  memcpy (&u, &CONST_DOUBLE_LOW (immed[i]), sizeof u);
 		  if (GET_MODE (immed[i]) == DFmode)
 		    ASM_OUTPUT_DOUBLE (file, u.d);
 		  else
diff --git a/gcc/config/rs6000/rs6000.c b/gcc/config/rs6000/rs6000.c
index 789a2f7f48f..bbefa7e2a88 100644
--- a/gcc/config/rs6000/rs6000.c
+++ b/gcc/config/rs6000/rs6000.c
@@ -385,8 +385,7 @@ rs6000_override_options (default_cpu)
   /* If the user desires alternate register names, copy in the alternate names
      now.  */
   if (TARGET_REGNAMES)
-    bcopy ((char *)alt_reg_names, (char *)rs6000_reg_names,
-	   sizeof (rs6000_reg_names));
+    memcpy (rs6000_reg_names, alt_reg_names, sizeof (rs6000_reg_names));
 #endif
 
 #ifdef SUBTARGET_OVERRIDE_OPTIONS
diff --git a/gcc/config/sh/sh.md b/gcc/config/sh/sh.md
index 4021fb2c76e..a9b86c4be8e 100644
--- a/gcc/config/sh/sh.md
+++ b/gcc/config/sh/sh.md
@@ -3877,7 +3877,7 @@
  "*
 {
   union real_extract u;
-  bcopy ((char *) &CONST_DOUBLE_LOW (operands[0]), (char *) &u, sizeof u);
+  memcpy (&u, &CONST_DOUBLE_LOW (operands[0]), sizeof u);
   assemble_real (u.d, SFmode);
   return \"\";
 }"
@@ -3892,7 +3892,7 @@
  "*
 {
   union real_extract u;
-  bcopy ((char *) &CONST_DOUBLE_LOW (operands[0]), (char *) &u, sizeof u);
+  memcpy (&u, &CONST_DOUBLE_LOW (operands[0]), sizeof u);
   assemble_real (u.d, DFmode);
   return \"\";
 }"
diff --git a/gcc/config/vax/vax.c b/gcc/config/vax/vax.c
index 77af581748c..38c86f05351 100644
--- a/gcc/config/vax/vax.c
+++ b/gcc/config/vax/vax.c
@@ -632,7 +632,7 @@ check_float_value (mode, d, overflow)
   if ((mode) == SFmode)
     {
       REAL_VALUE_TYPE r;
-      bcopy ((char *) d, (char *) &r, sizeof (REAL_VALUE_TYPE));
+      memcpy (&r, d, sizeof (REAL_VALUE_TYPE));
       if (REAL_VALUES_LESS (float_values[0], r))
 	{
 	  bcopy ((char *) &float_values[0], (char *) d,
diff --git a/gcc/cp/ChangeLog b/gcc/cp/ChangeLog
index f05fc60c4a7..a84276e3f8b 100644
--- a/gcc/cp/ChangeLog
+++ b/gcc/cp/ChangeLog
@@ -1,3 +1,8 @@
+2000-11-10  Kaveh R. Ghazi  <ghazi@caip.rutgers.edu>
+
+	* decl.c (grokdeclarator, save_function_data): Use memcpy, not bcopy.
+	* lex.c (copy_lang_decl): Likewise.
+
 2000-11-09  Mark Mitchell  <mark@codesourcery.com>
 
 	* dump.c (cp_dump_tree): Don't dump function bodies here.
diff --git a/gcc/cp/decl.c b/gcc/cp/decl.c
index a66500f9dcf..d23ef2f75f8 100644
--- a/gcc/cp/decl.c
+++ b/gcc/cp/decl.c
@@ -10703,7 +10703,7 @@ grokdeclarator (declarator, declspecs, decl_context, initialized, attrlist)
  		      }
 		    {
 		      RID_BIT_TYPE tmp_bits;
-		      bcopy ((void*)&specbits, (void*)&tmp_bits, sizeof (RID_BIT_TYPE));
+		      memcpy (&tmp_bits, &specbits, sizeof (RID_BIT_TYPE));
 		      RIDBIT_RESET (RID_INLINE, tmp_bits);
 		      RIDBIT_RESET (RID_STATIC, tmp_bits);
 		      if (RIDBIT_ANY_SET (tmp_bits))
@@ -14028,8 +14028,7 @@ save_function_data (decl)
   /* Make a copy.  */
   f = ((struct cp_language_function *)
        xmalloc (sizeof (struct cp_language_function)));
-  bcopy ((char *) cp_function_chain, (char *) f,
-	 sizeof (struct cp_language_function));
+  memcpy (f, cp_function_chain, sizeof (struct cp_language_function));
   DECL_SAVED_FUNCTION_DATA (decl) = f;
 
   /* Clear out the bits we don't need.  */
diff --git a/gcc/cp/lex.c b/gcc/cp/lex.c
index e7c1e550de1..0300deecb52 100644
--- a/gcc/cp/lex.c
+++ b/gcc/cp/lex.c
@@ -1588,7 +1588,7 @@ copy_lang_decl (node)
   else
     size = sizeof (struct lang_decl);
   ld = (struct lang_decl *) ggc_alloc (size);
-  bcopy ((char *)DECL_LANG_SPECIFIC (node), (char *)ld, size);
+  memcpy (ld, DECL_LANG_SPECIFIC (node), size);
   DECL_LANG_SPECIFIC (node) = ld;
 }
 
diff --git a/gcc/emit-rtl.c b/gcc/emit-rtl.c
index c73b346fe5b..db1c73fc936 100644
--- a/gcc/emit-rtl.c
+++ b/gcc/emit-rtl.c
@@ -1904,7 +1904,7 @@ copy_rtx_if_shared (orig)
       register rtx copy;
 
       copy = rtx_alloc (code);
-      bcopy ((char *) x, (char *) copy,
+      memcpy (copy, x,
 	     (sizeof (*copy) - sizeof (copy->fld)
 	      + sizeof (copy->fld[0]) * GET_RTX_LENGTH (code)));
       x = copy;
@@ -4109,7 +4109,7 @@ init_emit_once (line_numbers)
 	  memset ((char *) &u, 0, sizeof u);  /* Zero any holes in a structure.  */
 	  u.d = i == 0 ? dconst0 : i == 1 ? dconst1 : dconst2;
 
-	  bcopy ((char *) &u, (char *) &CONST_DOUBLE_LOW (tem), sizeof u);
+	  memcpy (&CONST_DOUBLE_LOW (tem), &u, sizeof u);
 	  CONST_DOUBLE_MEM (tem) = cc0_rtx;
 	  CONST_DOUBLE_CHAIN (tem) = NULL_RTX;
 	  PUT_MODE (tem, mode);
diff --git a/gcc/expmed.c b/gcc/expmed.c
index 012a68e8afa..af5d36d6de1 100644
--- a/gcc/expmed.c
+++ b/gcc/expmed.c
@@ -2314,10 +2314,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 ((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);
+  memcpy (alg_out->op, best_alg->op,
+	  alg_out->ops * sizeof *alg_out->op);
+  memcpy (alg_out->log, best_alg->log,
+	  alg_out->ops * sizeof *alg_out->log);
 }
 
 /* Perform a multiplication and return an rtx for the result.
diff --git a/gcc/final.c b/gcc/final.c
index 9b76aa801a3..c83f722f03e 100644
--- a/gcc/final.c
+++ b/gcc/final.c
@@ -1904,7 +1904,7 @@ add_bb_string (string, perm_p)
   if (!perm_p)
     {
       char *p = (char *) permalloc (len);
-      bcopy (string, p, len);
+      memcpy (p, string, len);
       string = p;
     }
   else
diff --git a/gcc/genattr.c b/gcc/genattr.c
index 770379a53d5..27123d87871 100644
--- a/gcc/genattr.c
+++ b/gcc/genattr.c
@@ -283,7 +283,7 @@ from the machine description file `md'.  */\n\n");
 	      unit = (struct function_unit *)
 		alloca (sizeof (struct function_unit));
 	      unit->name = (char *) alloca (len);
-	      bcopy (name, unit->name, len);
+	      memcpy (unit->name, name, len);
 	      unit->multiplicity = multiplicity;
 	      unit->simultaneity = simultaneity;
 	      unit->ready_cost.min = unit->ready_cost.max = ready_cost;
diff --git a/gcc/genattrtab.c b/gcc/genattrtab.c
index d3f77b0640d..98b11256610 100644
--- a/gcc/genattrtab.c
+++ b/gcc/genattrtab.c
@@ -808,7 +808,7 @@ attr_string (str, len)
 
   /* Not found; create a permanent copy and add it to the hash table.  */
   new_str = (char *) obstack_alloc (hash_obstack, len + 1);
-  bcopy (str, new_str, len);
+  memcpy (new_str, str, len);
   new_str[len] = '\0';
   attr_hash_add_string (hashcode, new_str);
 
@@ -2577,7 +2577,7 @@ simplify_cond (exp, insn_code, insn_index)
   /* This lets us free all storage allocated below, if appropriate.  */
   first_spacer = (char *) obstack_finish (rtl_obstack);
 
-  bcopy ((char *) XVEC (exp, 0)->elem, (char *) tests, len * sizeof (rtx));
+  memcpy (tests, XVEC (exp, 0)->elem, len * sizeof (rtx));
 
   /* See if default value needs simplification.  */
   if (GET_CODE (defval) == COND)
@@ -2665,8 +2665,7 @@ simplify_cond (exp, insn_code, insn_index)
       rtx newexp = rtx_alloc (COND);
 
       XVEC (newexp, 0) = rtvec_alloc (len);
-      bcopy ((char *) tests, (char *) XVEC (newexp, 0)->elem,
-	     len * sizeof (rtx));
+      memcpy (XVEC (newexp, 0)->elem, tests, len * sizeof (rtx));
       XEXP (newexp, 1) = new_defval;
       return newexp;
     }
@@ -5931,8 +5930,8 @@ copy_rtx_unchanging (orig)
   PUT_MODE (copy, GET_MODE (orig));
   RTX_UNCHANGING_P (copy) = 1;
 
-  bcopy ((char *) &XEXP (orig, 0), (char *) &XEXP (copy, 0),
-	 GET_RTX_LENGTH (GET_CODE (copy)) * sizeof (rtx));
+  memcpy (&XEXP (copy, 0), &XEXP (orig, 0),
+	  GET_RTX_LENGTH (GET_CODE (copy)) * sizeof (rtx));
   return copy;
 #endif
 }
diff --git a/gcc/java/ChangeLog b/gcc/java/ChangeLog
index 7ca5533d975..0a59c097d0c 100644
--- a/gcc/java/ChangeLog
+++ b/gcc/java/ChangeLog
@@ -1,3 +1,8 @@
+2000-11-10  Kaveh R. Ghazi  <ghazi@caip.rutgers.edu>
+
+	* decl.c (copy_lang_decl): Use memcpy, not bcopy.
+	* jcf-parse.c (jcf_figure_file_type): Likewise.
+
 2000-11-09  Joseph S. Myers  <jsm28@cam.ac.uk>
 
 	* parse.y (create_new_parser_context): Use memset () instead of
diff --git a/gcc/java/decl.c b/gcc/java/decl.c
index 5ae29856026..04e0734054b 100644
--- a/gcc/java/decl.c
+++ b/gcc/java/decl.c
@@ -1556,7 +1556,7 @@ copy_lang_decl (node)
     = TREE_CODE (node) == VAR_DECL ? sizeof (struct lang_decl_var)
     : sizeof (struct lang_decl);
   struct lang_decl *x = (struct lang_decl *) ggc_alloc (lang_decl_size);
-  bcopy ((PTR) DECL_LANG_SPECIFIC (node), (PTR) x, lang_decl_size);
+  memcpy (x, DECL_LANG_SPECIFIC (node), lang_decl_size);
   DECL_LANG_SPECIFIC (node) = x;
 }
 
diff --git a/gcc/java/jcf-parse.c b/gcc/java/jcf-parse.c
index 090120a1c6c..be9e7b958fa 100644
--- a/gcc/java/jcf-parse.c
+++ b/gcc/java/jcf-parse.c
@@ -1069,8 +1069,7 @@ DEFUN(jcf_figure_file_type, (jcf),
       && !open_in_zip (jcf, input_filename, NULL, 0))
     {
       localToFile = ALLOC (sizeof (struct ZipFileCache));
-      bcopy ((PTR) SeenZipFiles, (PTR) localToFile, 
-	     sizeof (struct ZipFileCache));
+      memcpy (localToFile, SeenZipFiles, sizeof (struct ZipFileCache));
       process_zip_dir ();	/* Register all the class defined there */
       return JCF_ZIP;
     }
diff --git a/gcc/jump.c b/gcc/jump.c
index 4c9c5ea2fae..d6941c83ffa 100644
--- a/gcc/jump.c
+++ b/gcc/jump.c
@@ -3748,8 +3748,7 @@ thread_jumps (f, max_reg, flag_before_loop)
 	  memset (modified_regs, 0, max_reg * sizeof (char));
 	  modified_mem = 0;
 
-	  bcopy ((char *) all_reset, (char *) same_regs,
-		 max_reg * sizeof (int));
+	  memcpy (same_regs, all_reset, max_reg * sizeof (int));
 	  num_same_regs = 0;
 
 	  label = JUMP_LABEL (b1);
diff --git a/gcc/prefix.c b/gcc/prefix.c
index 4789ed82b97..c43e5789d52 100644
--- a/gcc/prefix.c
+++ b/gcc/prefix.c
@@ -172,7 +172,7 @@ save_string (s, len)
 {
   register char *result = xmalloc (len + 1);
 
-  bcopy (s, result, len);
+  memcpy (result, s, len);
   result[len] = 0;
   return result;
 }
diff --git a/gcc/real.h b/gcc/real.h
index a6ea868a675..970c24c324d 100644
--- a/gcc/real.h
+++ b/gcc/real.h
@@ -464,7 +464,7 @@ REAL_VALUE_TYPE real_value_from_int_cst	PARAMS ((union tree_node *,
 
 #define REAL_VALUE_FROM_CONST_DOUBLE(to, from)		\
 do { union real_extract u;				\
-     bcopy ((char *) &CONST_DOUBLE_LOW ((from)), (char *) &u, sizeof u); \
+     memcpy (&u, &CONST_DOUBLE_LOW ((from)), 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 bf6fa0f6b3b..b9817a27174 100644
--- a/gcc/regclass.c
+++ b/gcc/regclass.c
@@ -267,8 +267,8 @@ init_reg_sets ()
 	  SET_HARD_REG_BIT (reg_class_contents[i], j);
     }
 
-  bcopy (initial_fixed_regs, fixed_regs, sizeof fixed_regs);
-  bcopy (initial_call_used_regs, call_used_regs, sizeof call_used_regs);
+  memcpy (fixed_regs, initial_fixed_regs, sizeof fixed_regs);
+  memcpy (call_used_regs, initial_call_used_regs, sizeof call_used_regs);
   memset (global_regs, 0, sizeof global_regs);
 
   /* Do any additional initialization regsets may need */
@@ -404,7 +404,7 @@ init_reg_sets_1 ()
   CLEAR_HARD_REG_SET (call_used_reg_set);
   CLEAR_HARD_REG_SET (call_fixed_reg_set);
 
-  bcopy (fixed_regs, call_fixed_regs, sizeof call_fixed_regs);
+  memcpy (call_fixed_regs, fixed_regs, sizeof call_fixed_regs);
 
   n_non_fixed_regs = 0;
 
diff --git a/gcc/reload1.c b/gcc/reload1.c
index 5219e8a09d2..dbe13fa6f51 100644
--- a/gcc/reload1.c
+++ b/gcc/reload1.c
@@ -669,7 +669,7 @@ reload (first, global)
   reg_equiv_address = (rtx *) xcalloc (max_regno, sizeof (rtx));
   reg_max_ref_width = (unsigned int *) xcalloc (max_regno, sizeof (int));
   reg_old_renumber = (short *) xcalloc (max_regno, sizeof (short));
-  bcopy ((PTR) reg_renumber, (PTR) reg_old_renumber, max_regno * sizeof (short));
+  memcpy (reg_old_renumber, reg_renumber, max_regno * sizeof (short));
   pseudo_forbidden_regs
     = (HARD_REG_SET *) xmalloc (max_regno * sizeof (HARD_REG_SET));
   pseudo_previous_regs
@@ -2530,9 +2530,9 @@ eliminate_regs (x, mem_mode, insn)
 	  if (new != XEXP (x, i) && ! copied)
 	    {
 	      rtx new_x = rtx_alloc (code);
-	      bcopy ((char *) x, (char *) new_x,
-		     (sizeof (*new_x) - sizeof (new_x->fld)
-		      + sizeof (new_x->fld[0]) * GET_RTX_LENGTH (code)));
+	      memcpy (new_x, x,
+		      (sizeof (*new_x) - sizeof (new_x->fld)
+		       + sizeof (new_x->fld[0]) * GET_RTX_LENGTH (code)));
 	      x = new_x;
 	      copied = 1;
 	    }
@@ -2551,10 +2551,10 @@ eliminate_regs (x, mem_mode, insn)
 		  if (! copied)
 		    {
 		      rtx new_x = rtx_alloc (code);
-		      bcopy ((char *) x, (char *) new_x,
-			     (sizeof (*new_x) - sizeof (new_x->fld)
-			      + (sizeof (new_x->fld[0])
-				 * GET_RTX_LENGTH (code))));
+		      memcpy (new_x, x,
+			      (sizeof (*new_x) - sizeof (new_x->fld)
+			       + (sizeof (new_x->fld[0])
+				  * GET_RTX_LENGTH (code))));
 		      x = new_x;
 		      copied = 1;
 		    }