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

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

From-SVN: r37367

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

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,

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,
+	      memcpy (&u, &CONST_DOUBLE_LOW (operands[1]), sizeof (u));
-		     sizeof (u));
 	      REAL_VALUE_TO_TARGET_DOUBLE (u.d, l);
 	      otherops[1] = GEN_INT (l[1]);
 	      operands[1] = GEN_INT (l[0]);

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,
+        memcpy (&u, &CONST_DOUBLE_LOW (operands[0]), sizeof u);
-					   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,
+          memcpy (&u, &CONST_DOUBLE_LOW (operands[0]), sizeof u);
-					     sizeof u);
           assemble_real (u.d, GET_MODE (operands[0]));
           break;
         }

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

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,	\
+  memcpy (reg_alloc_order, regs_ever_live[1] ? nonleaf : leaf,	\
-	 FIRST_PSEUDO_REGISTER * sizeof (int));			\
+	  FIRST_PSEUDO_REGISTER * sizeof (int));		\
 }
 
 /*** Register Classes ***/

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;

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,
+    memcpy (mips_reg_names, mips_sw_reg_names, sizeof (mips_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.  */

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 \"\";
 }"

gcc/config/romp/romp.c

@@ -1957,8 +1957,7 @@ output_fpops (file)
 		{
 		  union real_extract u;
 
-		  bcopy ((char *) &CONST_DOUBLE_LOW (immed[i]),
+		  memcpy (&u, &CONST_DOUBLE_LOW (immed[i]), sizeof u);
-			 (char *) &u, sizeof u);
 		  if (GET_MODE (immed[i]) == DFmode)
 		    ASM_OUTPUT_DOUBLE (file, u.d);
 		  else

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,
+    memcpy (rs6000_reg_names, alt_reg_names, sizeof (rs6000_reg_names));
-	   sizeof (rs6000_reg_names));
 #endif
 
 #ifdef SUBTARGET_OVERRIDE_OPTIONS

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 \"\";
 }"

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,

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.

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,
+  memcpy (f, cp_function_chain, sizeof (struct cp_language_function));
-	 sizeof (struct cp_language_function));
   DECL_SAVED_FUNCTION_DATA (decl) = f;
 
   /* Clear out the bits we don't need.  */

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

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

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,
+  memcpy (alg_out->op, best_alg->op,
-	 alg_out->ops * sizeof *alg_out->op);
+	  alg_out->ops * sizeof *alg_out->op);
-  bcopy ((char *) best_alg->log, (char *) alg_out->log,
+  memcpy (alg_out->log, best_alg->log,
-	 alg_out->ops * sizeof *alg_out->log);
+	  alg_out->ops * sizeof *alg_out->log);
 }
 
 /* Perform a multiplication and return an rtx for the result.

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

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;

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,
+      memcpy (XVEC (newexp, 0)->elem, tests, len * sizeof (rtx));
-	     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),
+  memcpy (&XEXP (copy, 0), &XEXP (orig, 0),
-	 GET_RTX_LENGTH (GET_CODE (copy)) * sizeof (rtx));
+	  GET_RTX_LENGTH (GET_CODE (copy)) * sizeof (rtx));
   return copy;
 #endif
 }

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

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

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, 
+      memcpy (localToFile, SeenZipFiles, sizeof (struct ZipFileCache));
-	     sizeof (struct ZipFileCache));
       process_zip_dir ();	/* Register all the class defined there */
       return JCF_ZIP;
     }

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,
+	  memcpy (same_regs, all_reset, max_reg * sizeof (int));
-		 max_reg * sizeof (int));
 	  num_same_regs = 0;
 
 	  label = JUMP_LABEL (b1);

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

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

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);
+  memcpy (fixed_regs, initial_fixed_regs, sizeof fixed_regs);
-  bcopy (initial_call_used_regs, call_used_regs, sizeof call_used_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;
 

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,
+	      memcpy (new_x, x,
-		     (sizeof (*new_x) - sizeof (new_x->fld)
+		      (sizeof (*new_x) - sizeof (new_x->fld)
-		      + sizeof (new_x->fld[0]) * GET_RTX_LENGTH (code)));
+		       + 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,
+		      memcpy (new_x, x,
-			     (sizeof (*new_x) - sizeof (new_x->fld)
+			      (sizeof (*new_x) - sizeof (new_x->fld)
-			      + (sizeof (new_x->fld[0])
+			       + (sizeof (new_x->fld[0])
-				 * GET_RTX_LENGTH (code))));
+				  * GET_RTX_LENGTH (code))));
 		      x = new_x;
 		      copied = 1;
 		    }