Replace bcopy, bzero, bcmp by memcpy, memmove, memset, memcmp

* alloc.c (overrun_check_malloc, overrun_check_realloc)
(overrun_check_free, xstrdup, allocate_string)
(allocate_string_data, compact_small_strings, Fmake_string)
(make_unibyte_string, make_multibyte_string)
(make_string_from_bytes, make_specified_string, make_float)
(Fcons, allocate_terminal, allocate_frame, make_pure_string)
(Fgarbage_collect): Replace bcopy, safe_bcopy, bzero, bcmp by
memcpy, memmove, memset, memcmp.
* atimer.c (start_atimer, set_alarm): Likewise.
* buffer.c (clone_per_buffer_values, report_overlay_modification)
(mmap_realloc, init_buffer_once): Likewise.
* callint.c (Fcall_interactively): Likewise.
* callproc.c (Fcall_process, Fcall_process_region, child_setup)
(getenv_internal_1): Likewise.
* casefiddle.c (casify_object): Likewise.
* ccl.c (ccl_driver): Likewise.
* character.c (str_as_multibyte, str_to_multibyte): Likewise.
* charset.c (load_charset_map_from_file)
(load_charset_map_from_file, load_charset_map_from_vector)
(Fdefine_charset_internal): Likewise.
* cm.c (Wcm_clear): Likewise.
* coding.c (decode_eol, decode_coding_object)
(Fset_coding_system_priority, make_subsidiaries): Likewise.
* data.c (Faset): Likewise.
* dired.c (directory_files_internal, file_name_completion_stat):
Likewise.
* dispnew.c (new_glyph_matrix, adjust_glyph_matrix)
(clear_glyph_row, copy_row_except_pointers)
(copy_glyph_row_contents, new_glyph_pool, realloc_glyph_pool)
(save_current_matrix, restore_current_matrix)
(build_frame_matrix_from_leaf_window, mirrored_line_dance)
(mirror_line_dance, scrolling_window): Likewise.
* doc.c (Fsnarf_documentation, Fsubstitute_command_keys):
Likewise.
* doprnt.c (doprnt): Likewise.
* editfns.c (Fuser_full_name, make_buffer_string_both)
(Fmessage_box, Fformat, Ftranspose_regions): Likewise.
* emacs.c (sort_args): Likewise.
* eval.c (Fapply, Ffuncall): Likewise.
* fileio.c (Ffile_name_directory, make_temp_name)
(Fexpand_file_name, search_embedded_absfilename)
(Fsubstitute_in_file_name, Ffile_symlink_p, Finsert_file_contents)
(auto_save_error): Likewise.
* fns.c (Fstring_equal, Fcopy_sequence, concat)
(string_to_multibyte, Fstring_as_unibyte, Fstring_as_multibyte)
(internal_equal, Fclear_string, larger_vector, copy_hash_table)
(Fmake_hash_table): Likewise.
* fringe.c (Fdefine_fringe_bitmap): Likewise.
* ftfont.c (ftfont_text_extents): Likewise.
* getloadavg.c (getloadavg): Likewise.
* image.c (define_image_type, make_image, make_image_cache)
(x_create_x_image_and_pixmap, xbm_image_p)
(w32_create_pixmap_from_bitmap_data, xbm_load, xpm_lookup_color)
(xpm_image_p, x_create_bitmap_from_xpm_data, xpm_load)
(init_color_table, x_build_heuristic_mask, pbm_image_p, pbm_load)
(png_image_p, png_read_from_memory, png_load, jpeg_image_p)
(tiff_image_p, tiff_read_from_memory, gif_image_p)
(gif_read_from_memory, gif_load, svg_image_p, gs_image_p):
Likewise.
* indent.c (scan_for_column, compute_motion): Likewise.
* insdel.c (gap_left, gap_right, make_gap_smaller, copy_text)
(insert_1_both, insert_from_gap, replace_range_2): Likewise.
* intervals.c (reproduce_tree, reproduce_tree_obj): Likewise.
* keyboard.c (echo_char, save_getcjmp, restore_getcjmp)
(kbd_buffer_store_event_hold, apply_modifiers_uncached)
(store_user_signal_events, menu_bar_items, tool_bar_items)
(process_tool_bar_item, append_tool_bar_item)
(read_char_minibuf_menu_prompt, read_key_sequence)
(Fread_key_sequence, Fread_key_sequence_vector, Frecent_keys):
Likewise.
* keymap.c (current_minor_maps, Fdescribe_buffer_bindings):
Likewise.
* lisp.h (STRING_COPYIN): Likewise.
* lread.c (Fload, read1, oblookup): Likewise.
* msdos.c (Frecent_doskeys): Likewise.
* nsfns.m (Fx_create_frame): Likewise.
* nsfont.m (nsfont_open, nsfont_text_extents, ns_glyph_metrics):
Likewise.
* nsimage.m (EmacsImage-initFromSkipXBM:width:height:)
(EmacsImage-initForXPMWithDepth:width:height:flip:length:):
Likewise.
* nsmenu.m (ns_update_menubar): Likewise.
* nsterm.m (ns_draw_fringe_bitmap, ns_term_init): Likewise.
* print.c (print_unwind, printchar, strout, print_string)
(print_error_message): Likewise.
* process.c (conv_lisp_to_sockaddr, set_socket_option)
(Fmake_network_process, Fnetwork_interface_list)
(Fnetwork_interface_info, read_process_output, Fprocess_send_eof)
(init_process): Likewise.
* ralloc.c (resize_bloc, r_alloc_sbrk, r_alloc_init): Likewise.
* regex.c (init_syntax_once, regex_compile, re_compile_fastmap):
Likewise.
* scroll.c (do_scrolling, do_direct_scrolling)
(scrolling_max_lines_saved): Likewise.
* search.c (search_buffer, wordify, Freplace_match): Likewise.
* sound.c (wav_init, au_init, Fplay_sound_internal): Likewise.
* syntax.c (skip_chars, skip_syntaxes): Likewise.
* sysdep.c (child_setup_tty, sys_subshell, emacs_get_tty)
(emacs_set_tty): Likewise.
* term.c (encode_terminal_code, calculate_costs)
(produce_special_glyphs, create_tty_output, init_tty, delete_tty):
Likewise.
* termcap.c (tgetst1, gobble_line): Likewise.
* termhooks.h (EVENT_INIT): Likewise.
* tparam.c (tparam1): Likewise.
* unexalpha.c (unexec): Likewise.
* unexec.c (write_segment): Likewise.
* unexmacosx.c (unexec_write_zero): Likewise.
* w32fns.c (w32_wnd_proc, Fx_create_frame, x_create_tip_frame)
(Fx_file_dialog, Fsystem_move_file_to_trash): Likewise.
* w32font.c (w32font_list_family, w32font_text_extents)
(w32font_list_internal, w32font_match_internal)
(w32font_open_internal, compute_metrics, Fx_select_font):
Likewise.
* w32menu.c (set_frame_menubar, add_menu_item)
(w32_menu_display_help, w32_free_submenu_strings): Likewise.
* w32term.c (XCreateGC, w32_initialize_display_info): Likewise.
* w32uniscribe.c (uniscribe_list_family): Likewise.
* w32xfns.c (get_next_msg, post_msg, prepend_msg): Likewise.
* window.c (make_window, replace_window, set_window_buffer)
(Fsplit_window): Likewise.
* xdisp.c (init_iterator, RECORD_OVERLAY_STRING, reseat_to_string)
(add_to_log, message3, x_consider_frame_title)
(append_space_for_newline, extend_face_to_end_of_line)
(decode_mode_spec_coding, init_glyph_string): Likewise.
* xfaces.c (x_create_gc, get_lface_attributes_no_remap)
(Finternal_copy_lisp_face, Finternal_merge_in_global_face)
(face_attr_equal_p, make_realized_face, make_face_cache)
(free_realized_faces, lookup_named_face, smaller_face)
(face_with_height, lookup_derived_face)
(x_supports_face_attributes_p, Finternal_set_font_selection_order)
(Finternal_set_font_selection_order, realize_default_face)
(compute_char_face, face_at_buffer_position)
(face_for_overlay_string, face_at_string_position, merge_faces):
Likewise.
* xfns.c (xic_create_fontsetname, Fx_create_frame)
(Fx_window_property, x_create_tip_frame)
(Fx_backspace_delete_keys_p): Likewise.
* xfont.c (xfont_list, xfont_match, xfont_list_family)
(xfont_text_extents): Likewise.
* xmenu.c (set_frame_menubar, xmenu_show): Likewise.
* xrdb.c (magic_file_p, x_get_resource): Likewise.
* xselect.c (x_queue_event, x_get_window_property)
(receive_incremental_selection): Likewise.
* xsmfns.c (x_session_check_input): Likewise.
* xterm.c (x_send_scroll_bar_event, SET_SAVED_MENU_EVENT)
(handle_one_xevent, x_check_errors, xim_initialize, x_term_init):
Likewise.
* character.h (BCOPY_SHORT): Removed.
* config.in: Regenerate.
* dispnew.c (safe_bcopy): Only define as dummy if PROFILING.
* emacs.c (main) [PROFILING]: Don't declare
dump_opcode_frequencies.
* lisp.h (safe_bcopy): Remove declaration.
(memset) [!HAVE_MEMSET]: Declare.
(memcpy) [!HAVE_MEMCPY]: Likewise.
(memmove) [!HAVE_MEMMOVE]: Likewise.
(memcmp) [!HAVE_MEMCMP]: Likewise.
* s/ms-w32.h (bzero, bcopy, bcmp, GAP_USE_BCOPY)
(BCOPY_UPWARD_SAFE, BCOPY_DOWNWARD_SAFE, HAVE_BCOPY, HAVE_BCMP):
Don't define.
(HAVE_MEMCMP, HAVE_MEMCPY, HAVE_MEMMOVE, HAVE_MEMSET): Define.
* s/msdos.h (GAP_USE_BCOPY, BCOPY_UPWARD_SAFE)
(BCOPY_DOWNWARD_SAFE): Don't define.
* sysdep.c (memset) [!HAVE_MEMSET]: Define.
(memcpy) [!HAVE_MEMCPY]: Define.
(memmove) [!HAVE_MEMMOVE]: Define.
(memcmp) [!HAVE_MEMCMP]: Define.

* config.nt (HAVE_BCOPY, HAVE_BCMP): Remove undefs.
(HAVE_MEMCPY, HAVE_MEMMOVE, HAVE_MEMSET, HAVE_MEMCMP): Add undefs.

* sed2v2.inp (HAVE_MEMCPY, HAVE_MEMSET): Edit to 1.
(HAVE_BZERO): Don't edit.

* lwlib.c (lwlib_memset, lwlib_bcopy): Remove.
(malloc_widget_value, free_widget_info, allocate_widget_instance)
(lw_separator_p): Replace lwlib_memset, lwlib_bcopy, bzero, bcmp by
memset, memcpy, memcmp.
* lwlib-utils.c (XtApplyToWidgets): Likewise.
* xlwmenu.c (XlwMenuInitialize): Likewise.
* lwlib.h (lwlib_bcopy): Remove declaration.

* ebrowse.c (add_sym, make_namespace): Replace bcopy, bzero by
memcpy, memmove, memset.
* pop.c (pop_retrieve, socket_connection, pop_getline): Likewise.

* CPP-DEFINES (BCOPY_DOWNWARD_SAFE, BCOPY_UPWARD_SAFE)
(GAP_USE_BCOPY, HAVE_BCMP, HAVE_BCOPY, bcmp, bcopy, bzero):
Remove.

* configure.in: Don't check for bcopy, bcmp, bzero.  Don't include
<strings.h> and don't define bcopy, bzero, BCMP in config.h.

75 files changed, 737 insertions, 686 deletions

diff --git a/src/ChangeLog b/src/ChangeLog
index 912a5a8d2f2..4896708b979 100644
--- a/src/ChangeLog
+++ b/src/ChangeLog
@@ -1,3 +1,174 @@
+2010-07-07  Andreas Schwab  <schwab@linux-m68k.org>
+
+        * alloc.c (overrun_check_malloc, overrun_check_realloc)
+        (overrun_check_free, xstrdup, allocate_string)
+        (allocate_string_data, compact_small_strings, Fmake_string)
+        (make_unibyte_string, make_multibyte_string)
+        (make_string_from_bytes, make_specified_string, make_float)
+        (Fcons, allocate_terminal, allocate_frame, make_pure_string)
+        (Fgarbage_collect): Replace bcopy, safe_bcopy, bzero, bcmp by
+        memcpy, memmove, memset, memcmp.
+        * atimer.c (start_atimer, set_alarm): Likewise.
+        * buffer.c (clone_per_buffer_values, report_overlay_modification)
+        (mmap_realloc, init_buffer_once): Likewise.
+        * callint.c (Fcall_interactively): Likewise.
+        * callproc.c (Fcall_process, Fcall_process_region, child_setup)
+        (getenv_internal_1): Likewise.
+        * casefiddle.c (casify_object): Likewise.
+        * ccl.c (ccl_driver): Likewise.
+        * character.c (str_as_multibyte, str_to_multibyte): Likewise.
+        * charset.c (load_charset_map_from_file)
+        (load_charset_map_from_file, load_charset_map_from_vector)
+        (Fdefine_charset_internal): Likewise.
+        * cm.c (Wcm_clear): Likewise.
+        * coding.c (decode_eol, decode_coding_object)
+        (Fset_coding_system_priority, make_subsidiaries): Likewise.
+        * data.c (Faset): Likewise.
+        * dired.c (directory_files_internal, file_name_completion_stat):
+        Likewise.
+        * dispnew.c (new_glyph_matrix, adjust_glyph_matrix)
+        (clear_glyph_row, copy_row_except_pointers)
+        (copy_glyph_row_contents, new_glyph_pool, realloc_glyph_pool)
+        (save_current_matrix, restore_current_matrix)
+        (build_frame_matrix_from_leaf_window, mirrored_line_dance)
+        (mirror_line_dance, scrolling_window): Likewise.
+        * doc.c (Fsnarf_documentation, Fsubstitute_command_keys):
+        Likewise.
+        * doprnt.c (doprnt): Likewise.
+        * editfns.c (Fuser_full_name, make_buffer_string_both)
+        (Fmessage_box, Fformat, Ftranspose_regions): Likewise.
+        * emacs.c (sort_args): Likewise.
+        * eval.c (Fapply, Ffuncall): Likewise.
+        * fileio.c (Ffile_name_directory, make_temp_name)
+        (Fexpand_file_name, search_embedded_absfilename)
+        (Fsubstitute_in_file_name, Ffile_symlink_p, Finsert_file_contents)
+        (auto_save_error): Likewise.
+        * fns.c (Fstring_equal, Fcopy_sequence, concat)
+        (string_to_multibyte, Fstring_as_unibyte, Fstring_as_multibyte)
+        (internal_equal, Fclear_string, larger_vector, copy_hash_table)
+        (Fmake_hash_table): Likewise.
+        * fringe.c (Fdefine_fringe_bitmap): Likewise.
+        * ftfont.c (ftfont_text_extents): Likewise.
+        * getloadavg.c (getloadavg): Likewise.
+        * image.c (define_image_type, make_image, make_image_cache)
+        (x_create_x_image_and_pixmap, xbm_image_p)
+        (w32_create_pixmap_from_bitmap_data, xbm_load, xpm_lookup_color)
+        (xpm_image_p, x_create_bitmap_from_xpm_data, xpm_load)
+        (init_color_table, x_build_heuristic_mask, pbm_image_p, pbm_load)
+        (png_image_p, png_read_from_memory, png_load, jpeg_image_p)
+        (tiff_image_p, tiff_read_from_memory, gif_image_p)
+        (gif_read_from_memory, gif_load, svg_image_p, gs_image_p):
+        Likewise.
+        * indent.c (scan_for_column, compute_motion): Likewise.
+        * insdel.c (gap_left, gap_right, make_gap_smaller, copy_text)
+        (insert_1_both, insert_from_gap, replace_range_2): Likewise.
+        * intervals.c (reproduce_tree, reproduce_tree_obj): Likewise.
+        * keyboard.c (echo_char, save_getcjmp, restore_getcjmp)
+        (kbd_buffer_store_event_hold, apply_modifiers_uncached)
+        (store_user_signal_events, menu_bar_items, tool_bar_items)
+        (process_tool_bar_item, append_tool_bar_item)
+        (read_char_minibuf_menu_prompt, read_key_sequence)
+        (Fread_key_sequence, Fread_key_sequence_vector, Frecent_keys):
+        Likewise.
+        * keymap.c (current_minor_maps, Fdescribe_buffer_bindings):
+        Likewise.
+        * lisp.h (STRING_COPYIN): Likewise.
+        * lread.c (Fload, read1, oblookup): Likewise.
+        * msdos.c (Frecent_doskeys): Likewise.
+        * nsfns.m (Fx_create_frame): Likewise.
+        * nsfont.m (nsfont_open, nsfont_text_extents, ns_glyph_metrics):
+        Likewise.
+        * nsimage.m (EmacsImage-initFromSkipXBM:width:height:)
+        (EmacsImage-initForXPMWithDepth:width:height:flip:length:):
+        Likewise.
+        * nsmenu.m (ns_update_menubar): Likewise.
+        * nsterm.m (ns_draw_fringe_bitmap, ns_term_init): Likewise.
+        * print.c (print_unwind, printchar, strout, print_string)
+        (print_error_message): Likewise.
+        * process.c (conv_lisp_to_sockaddr, set_socket_option)
+        (Fmake_network_process, Fnetwork_interface_list)
+        (Fnetwork_interface_info, read_process_output, Fprocess_send_eof)
+        (init_process): Likewise.
+        * ralloc.c (resize_bloc, r_alloc_sbrk, r_alloc_init): Likewise.
+        * regex.c (init_syntax_once, regex_compile, re_compile_fastmap):
+        Likewise.
+        * scroll.c (do_scrolling, do_direct_scrolling)
+        (scrolling_max_lines_saved): Likewise.
+        * search.c (search_buffer, wordify, Freplace_match): Likewise.
+        * sound.c (wav_init, au_init, Fplay_sound_internal): Likewise.
+        * syntax.c (skip_chars, skip_syntaxes): Likewise.
+        * sysdep.c (child_setup_tty, sys_subshell, emacs_get_tty)
+        (emacs_set_tty): Likewise.
+        * term.c (encode_terminal_code, calculate_costs)
+        (produce_special_glyphs, create_tty_output, init_tty, delete_tty):
+        Likewise.
+        * termcap.c (tgetst1, gobble_line): Likewise.
+        * termhooks.h (EVENT_INIT): Likewise.
+        * tparam.c (tparam1): Likewise.
+        * unexalpha.c (unexec): Likewise.
+        * unexec.c (write_segment): Likewise.
+        * unexmacosx.c (unexec_write_zero): Likewise.
+        * w32fns.c (w32_wnd_proc, Fx_create_frame, x_create_tip_frame)
+        (Fx_file_dialog, Fsystem_move_file_to_trash): Likewise.
+        * w32font.c (w32font_list_family, w32font_text_extents)
+        (w32font_list_internal, w32font_match_internal)
+        (w32font_open_internal, compute_metrics, Fx_select_font):
+        Likewise.
+        * w32menu.c (set_frame_menubar, add_menu_item)
+        (w32_menu_display_help, w32_free_submenu_strings): Likewise.
+        * w32term.c (XCreateGC, w32_initialize_display_info): Likewise.
+        * w32uniscribe.c (uniscribe_list_family): Likewise.
+        * w32xfns.c (get_next_msg, post_msg, prepend_msg): Likewise.
+        * window.c (make_window, replace_window, set_window_buffer)
+        (Fsplit_window): Likewise.
+        * xdisp.c (init_iterator, RECORD_OVERLAY_STRING, reseat_to_string)
+        (add_to_log, message3, x_consider_frame_title)
+        (append_space_for_newline, extend_face_to_end_of_line)
+        (decode_mode_spec_coding, init_glyph_string): Likewise.
+        * xfaces.c (x_create_gc, get_lface_attributes_no_remap)
+        (Finternal_copy_lisp_face, Finternal_merge_in_global_face)
+        (face_attr_equal_p, make_realized_face, make_face_cache)
+        (free_realized_faces, lookup_named_face, smaller_face)
+        (face_with_height, lookup_derived_face)
+        (x_supports_face_attributes_p, Finternal_set_font_selection_order)
+        (Finternal_set_font_selection_order, realize_default_face)
+        (compute_char_face, face_at_buffer_position)
+        (face_for_overlay_string, face_at_string_position, merge_faces):
+        Likewise.
+        * xfns.c (xic_create_fontsetname, Fx_create_frame)
+        (Fx_window_property, x_create_tip_frame)
+        (Fx_backspace_delete_keys_p): Likewise.
+        * xfont.c (xfont_list, xfont_match, xfont_list_family)
+        (xfont_text_extents): Likewise.
+        * xmenu.c (set_frame_menubar, xmenu_show): Likewise.
+        * xrdb.c (magic_file_p, x_get_resource): Likewise.
+        * xselect.c (x_queue_event, x_get_window_property)
+        (receive_incremental_selection): Likewise.
+        * xsmfns.c (x_session_check_input): Likewise.
+        * xterm.c (x_send_scroll_bar_event, SET_SAVED_MENU_EVENT)
+        (handle_one_xevent, x_check_errors, xim_initialize, x_term_init):
+        Likewise.
+        * character.h (BCOPY_SHORT): Removed.
+        * config.in: Regenerate.
+        * dispnew.c (safe_bcopy): Only define as dummy if PROFILING.
+        * emacs.c (main) [PROFILING]: Don't declare
+        dump_opcode_frequencies.
+        * lisp.h (safe_bcopy): Remove declaration.
+        (memset) [!HAVE_MEMSET]: Declare.
+        (memcpy) [!HAVE_MEMCPY]: Likewise.
+        (memmove) [!HAVE_MEMMOVE]: Likewise.
+        (memcmp) [!HAVE_MEMCMP]: Likewise.
+        * s/ms-w32.h (bzero, bcopy, bcmp, GAP_USE_BCOPY)
+        (BCOPY_UPWARD_SAFE, BCOPY_DOWNWARD_SAFE, HAVE_BCOPY, HAVE_BCMP):
+        Don't define.
+        (HAVE_MEMCMP, HAVE_MEMCPY, HAVE_MEMMOVE, HAVE_MEMSET): Define.
+        * s/msdos.h (GAP_USE_BCOPY, BCOPY_UPWARD_SAFE)
+        (BCOPY_DOWNWARD_SAFE): Don't define.
+        * sysdep.c (memset) [!HAVE_MEMSET]: Define.
+        (memcpy) [!HAVE_MEMCPY]: Define.
+        (memmove) [!HAVE_MEMMOVE]: Define.
+        (memcmp) [!HAVE_MEMCMP]: Define.
+
 2010-07-07  Jan Djärv  <jan.h.d@swipnet.se>
 
         * process.c (kbd_is_on_hold): New variable.
diff --git a/src/alloc.c b/src/alloc.c
index 7598386ebca..62b6e449831 100644
--- a/src/alloc.c
+++ b/src/alloc.c
@@ -636,10 +636,12 @@ overrun_check_malloc (size)
   val = (unsigned char *) malloc (size + overhead);
   if (val && check_depth == 1)
     {
-      bcopy (xmalloc_overrun_check_header, val, XMALLOC_OVERRUN_CHECK_SIZE - 4);
+      memcpy (val, xmalloc_overrun_check_header,
+              XMALLOC_OVERRUN_CHECK_SIZE - 4);
       val += XMALLOC_OVERRUN_CHECK_SIZE;
       XMALLOC_PUT_SIZE(val, size);
-      bcopy (xmalloc_overrun_check_trailer, val + size, XMALLOC_OVERRUN_CHECK_SIZE);
+      memcpy (val + size, xmalloc_overrun_check_trailer,
+              XMALLOC_OVERRUN_CHECK_SIZE);
     }
   --check_depth;
   return (POINTER_TYPE *)val;
@@ -659,28 +661,29 @@ overrun_check_realloc (block, size)
 
   if (val
       && check_depth == 1
-      && bcmp (xmalloc_overrun_check_header,
-               val - XMALLOC_OVERRUN_CHECK_SIZE,
-               XMALLOC_OVERRUN_CHECK_SIZE - 4) == 0)
+      && memcmp (xmalloc_overrun_check_header,
+                 val - XMALLOC_OVERRUN_CHECK_SIZE,
+                 XMALLOC_OVERRUN_CHECK_SIZE - 4) == 0)
     {
       size_t osize = XMALLOC_GET_SIZE (val);
-      if (bcmp (xmalloc_overrun_check_trailer,
-                val + osize,
-                XMALLOC_OVERRUN_CHECK_SIZE))
+      if (memcmp (xmalloc_overrun_check_trailer, val + osize,
+                  XMALLOC_OVERRUN_CHECK_SIZE))
         abort ();
-      bzero (val + osize, XMALLOC_OVERRUN_CHECK_SIZE);
+      memset (val + osize, 0, XMALLOC_OVERRUN_CHECK_SIZE);
       val -= XMALLOC_OVERRUN_CHECK_SIZE;
-      bzero (val, XMALLOC_OVERRUN_CHECK_SIZE);
+      memset (val, 0, XMALLOC_OVERRUN_CHECK_SIZE);
     }
 
   val = (unsigned char *) realloc ((POINTER_TYPE *)val, size + overhead);
 
   if (val && check_depth == 1)
     {
-      bcopy (xmalloc_overrun_check_header, val, XMALLOC_OVERRUN_CHECK_SIZE - 4);
+      memcpy (val, xmalloc_overrun_check_header,
+              XMALLOC_OVERRUN_CHECK_SIZE - 4);
       val += XMALLOC_OVERRUN_CHECK_SIZE;
       XMALLOC_PUT_SIZE(val, size);
-      bcopy (xmalloc_overrun_check_trailer, val + size, XMALLOC_OVERRUN_CHECK_SIZE);
+      memcpy (val + size, xmalloc_overrun_check_trailer,
+              XMALLOC_OVERRUN_CHECK_SIZE);
     }
   --check_depth;
   return (POINTER_TYPE *)val;
@@ -697,22 +700,21 @@ overrun_check_free (block)
   ++check_depth;
   if (val
       && check_depth == 1
-      && bcmp (xmalloc_overrun_check_header,
-               val - XMALLOC_OVERRUN_CHECK_SIZE,
-               XMALLOC_OVERRUN_CHECK_SIZE - 4) == 0)
+      && memcmp (xmalloc_overrun_check_header,
+                 val - XMALLOC_OVERRUN_CHECK_SIZE,
+                 XMALLOC_OVERRUN_CHECK_SIZE - 4) == 0)
     {
       size_t osize = XMALLOC_GET_SIZE (val);
-      if (bcmp (xmalloc_overrun_check_trailer,
-                val + osize,
-                XMALLOC_OVERRUN_CHECK_SIZE))
+      if (memcmp (xmalloc_overrun_check_trailer, val + osize,
+                  XMALLOC_OVERRUN_CHECK_SIZE))
         abort ();
 #ifdef XMALLOC_CLEAR_FREE_MEMORY
       val -= XMALLOC_OVERRUN_CHECK_SIZE;
       memset (val, 0xff, osize + XMALLOC_OVERRUN_CHECK_SIZE*2);
 #else
-      bzero (val + osize, XMALLOC_OVERRUN_CHECK_SIZE);
+      memset (val + osize, 0, XMALLOC_OVERRUN_CHECK_SIZE);
       val -= XMALLOC_OVERRUN_CHECK_SIZE;
-      bzero (val, XMALLOC_OVERRUN_CHECK_SIZE);
+      memset (val, 0, XMALLOC_OVERRUN_CHECK_SIZE);
 #endif
     }
 
@@ -799,7 +801,7 @@ xstrdup (const char *s)
 {
   size_t len = strlen (s) + 1;
   char *p = (char *) xmalloc (len);
-  bcopy (s, p, len);
+  memcpy (p, s, len);
   return p;
 }
 
@@ -1873,7 +1875,7 @@ allocate_string (void)
       int i;
 
       b = (struct string_block *) lisp_malloc (sizeof *b, MEM_TYPE_STRING);
-      bzero (b, sizeof *b);
+      memset (b, 0, sizeof *b);
       b->next = string_blocks;
       string_blocks = b;
       ++n_string_blocks;
@@ -1897,7 +1899,7 @@ allocate_string (void)
   MALLOC_UNBLOCK_INPUT;
 
   /* Probably not strictly necessary, but play it safe.  */
-  bzero (s, sizeof *s);
+  memset (s, 0, sizeof *s);
 
   --total_free_strings;
   ++total_strings;
@@ -2005,8 +2007,7 @@ allocate_string_data (struct Lisp_String *s, int nchars, int nbytes)
   s->size_byte = nbytes;
   s->data[nbytes] = '\0';
 #ifdef GC_CHECK_STRING_OVERRUN
-  bcopy (string_overrun_cookie, (char *) data + needed,
-         GC_STRING_OVERRUN_COOKIE_SIZE);
+  memcpy (data + needed, string_overrun_cookie, GC_STRING_OVERRUN_COOKIE_SIZE);
 #endif
 
   /* If S had already data assigned, mark that as free by setting its
@@ -2197,9 +2198,9 @@ compact_small_strings (void)
           from_end = (struct sdata *) ((char *) from + nbytes + GC_STRING_EXTRA);
 
 #ifdef GC_CHECK_STRING_OVERRUN
-          if (bcmp (string_overrun_cookie,
-                    ((char *) from_end) - GC_STRING_OVERRUN_COOKIE_SIZE,
-                    GC_STRING_OVERRUN_COOKIE_SIZE))
+          if (memcmp (string_overrun_cookie,
+                      (char *) from_end - GC_STRING_OVERRUN_COOKIE_SIZE,
+                      GC_STRING_OVERRUN_COOKIE_SIZE))
             abort ();
 #endif
 
@@ -2221,7 +2222,7 @@ compact_small_strings (void)
               if (from != to)
                 {
                   xassert (tb != b || to <= from);
-                  safe_bcopy ((char *) from, (char *) to, nbytes + GC_STRING_EXTRA);
+                  memmove (to, from, nbytes + GC_STRING_EXTRA);
                   to->string->data = SDATA_DATA (to);
                 }
 
@@ -2280,7 +2281,7 @@ INIT must be an integer that represents a character.  */)
       end = p + nbytes;
       while (p != end)
         {
-          bcopy (str, p, len);
+          memcpy (p, str, len);
           p += len;
         }
     }
@@ -2362,7 +2363,7 @@ make_unibyte_string (const char *contents, int length)
 {
   register Lisp_Object val;
   val = make_uninit_string (length);
-  bcopy (contents, SDATA (val), length);
+  memcpy (SDATA (val), contents, length);
   STRING_SET_UNIBYTE (val);
   return val;
 }
@@ -2376,7 +2377,7 @@ make_multibyte_string (const char *contents, int nchars, int nbytes)
 {
   register Lisp_Object val;
   val = make_uninit_multibyte_string (nchars, nbytes);
-  bcopy (contents, SDATA (val), nbytes);
+  memcpy (SDATA (val), contents, nbytes);
   return val;
 }
 
@@ -2389,7 +2390,7 @@ make_string_from_bytes (const char *contents, int nchars, int nbytes)
 {
   register Lisp_Object val;
   val = make_uninit_multibyte_string (nchars, nbytes);
-  bcopy (contents, SDATA (val), nbytes);
+  memcpy (SDATA (val), contents, nbytes);
   if (SBYTES (val) == SCHARS (val))
     STRING_SET_UNIBYTE (val);
   return val;
@@ -2414,7 +2415,7 @@ make_specified_string (const char *contents, int nchars, int nbytes, int multiby
         nchars = nbytes;
     }
   val = make_uninit_multibyte_string (nchars, nbytes);
-  bcopy (contents, SDATA (val), nbytes);
+  memcpy (SDATA (val), contents, nbytes);
   if (!multibyte)
     STRING_SET_UNIBYTE (val);
   return val;
@@ -2587,7 +2588,7 @@ make_float (double float_value)
           new = (struct float_block *) lisp_align_malloc (sizeof *new,
                                                           MEM_TYPE_FLOAT);
           new->next = float_block;
-          bzero ((char *) new->gcmarkbits, sizeof new->gcmarkbits);
+          memset (new->gcmarkbits, 0, sizeof new->gcmarkbits);
           float_block = new;
           float_block_index = 0;
           n_float_blocks++;
@@ -2709,7 +2710,7 @@ DEFUN ("cons", Fcons, Scons, 2, 2, 0,
           register struct cons_block *new;
           new = (struct cons_block *) lisp_align_malloc (sizeof *new,
                                                          MEM_TYPE_CONS);
-          bzero ((char *) new->gcmarkbits, sizeof new->gcmarkbits);
+          memset (new->gcmarkbits, 0, sizeof new->gcmarkbits);
           new->next = cons_block;
           cons_block = new;
           cons_block_index = 0;
@@ -2950,8 +2951,8 @@ allocate_terminal (void)
   struct terminal *t = ALLOCATE_PSEUDOVECTOR (struct terminal,
                                               next_terminal, PVEC_TERMINAL);
   /* Zero out the non-GC'd fields.  FIXME: This should be made unnecessary.  */
-  bzero (&(t->next_terminal),
-         ((char*)(t+1)) - ((char*)&(t->next_terminal)));
+  memset (&t->next_terminal, 0,
+          (char*) (t + 1) - (char*) &t->next_terminal);
 
   return t;
 }
@@ -2962,8 +2963,8 @@ allocate_frame (void)
   struct frame *f = ALLOCATE_PSEUDOVECTOR (struct frame,
                                            face_cache, PVEC_FRAME);
   /* Zero out the non-GC'd fields.  FIXME: This should be made unnecessary.  */
-  bzero (&(f->face_cache),
-         ((char*)(f+1)) - ((char*)&(f->face_cache)));
+  memset (&f->face_cache, 0,
+          (char *) (f + 1) - (char *) &f->face_cache);
   return f;
 }
 
@@ -4713,7 +4714,7 @@ make_pure_string (const char *data, int nchars, int nbytes, int multibyte)
   if (s->data == NULL)
     {
       s->data = (unsigned char *) pure_alloc (nbytes + 1, -1);
-      bcopy (data, s->data, nbytes);
+      memcpy (s->data, data, nbytes);
       s->data[nbytes] = '\0';
     }
   s->size = nchars;
@@ -4980,9 +4981,9 @@ returns nil, because real GC can't be done.  */)
           if (stack_copy)
             {
               if ((EMACS_INT) (&stack_top_variable - stack_bottom) > 0)
-                bcopy (stack_bottom, stack_copy, i);
+                memcpy (stack_copy, stack_bottom, i);
               else
-                bcopy (&stack_top_variable, stack_copy, i);
+                memcpy (stack_copy, &stack_top_variable, i);
             }
         }
     }
diff --git a/src/atimer.c b/src/atimer.c
index c9cf145ad85..9fd9dee835e 100644
--- a/src/atimer.c
+++ b/src/atimer.c
@@ -116,7 +116,7 @@ start_atimer (enum atimer_type type, EMACS_TIME time, atimer_callback fn,
     t = (struct atimer *) xmalloc (sizeof *t);
 
   /* Fill the atimer structure.  */
-  bzero (t, sizeof *t);
+  memset (t, 0, sizeof *t);
   t->type = type;
   t->fn = fn;
   t->client_data = client_data;
@@ -308,7 +308,7 @@ set_alarm (void)
           EMACS_SET_USECS (time, 1000);
         }
 
-      bzero (&it, sizeof it);
+      memset (&it, 0, sizeof it);
       it.it_value = time;
       setitimer (ITIMER_REAL, &it, 0);
 #else /* not HAVE_SETITIMER */
diff --git a/src/buffer.c b/src/buffer.c
index 57e4986a0bb..b8f19e96c43 100644
--- a/src/buffer.c
+++ b/src/buffer.c
@@ -514,7 +514,7 @@ clone_per_buffer_values (struct buffer *from, struct buffer *to)
       PER_BUFFER_VALUE (to, offset) = obj;
     }
 
-  bcopy (from->local_flags, to->local_flags, sizeof to->local_flags);
+  memcpy (to->local_flags, from->local_flags, sizeof to->local_flags);
 
   to->overlays_before = copy_overlays (to, from->overlays_before);
   to->overlays_after = copy_overlays (to, from->overlays_after);
@@ -4413,8 +4413,8 @@ report_overlay_modification (Lisp_Object start, Lisp_Object end, int after,
     Lisp_Object *copy = (Lisp_Object *) alloca (size * sizeof (Lisp_Object));
     int i;
 
-    bcopy (XVECTOR (last_overlay_modification_hooks)->contents,
-           copy, size * sizeof (Lisp_Object));
+    memcpy (copy, XVECTOR (last_overlay_modification_hooks)->contents,
+            size * sizeof (Lisp_Object));
     gcpro1.var = copy;
     gcpro1.nvars = size;
 
@@ -4877,7 +4877,7 @@ mmap_realloc (var, nbytes)
             }
           else if (mmap_alloc (var, nbytes))
             {
-              bcopy (old_ptr, *var, r->nbytes_specified);
+              memcpy (*var, old_ptr, r->nbytes_specified);
               mmap_free_1 (MMAP_REGION (old_ptr));
               result = *var;
               r = MMAP_REGION (result);
@@ -5058,7 +5058,7 @@ init_buffer_once (void)
 {
   int idx;
 
-  bzero (buffer_permanent_local_flags, sizeof buffer_permanent_local_flags);
+  memset (buffer_permanent_local_flags, 0, sizeof buffer_permanent_local_flags);
 
   /* Make sure all markable slots in buffer_defaults
      are initialized reasonably, so mark_buffer won't choke.  */
@@ -5146,7 +5146,7 @@ init_buffer_once (void)
   if (sizeof (EMACS_INT) != sizeof (Lisp_Object)) abort ();
 
   /* 0 means not a lisp var, -1 means always local, else mask */
-  bzero (&buffer_local_flags, sizeof buffer_local_flags);
+  memset (&buffer_local_flags, 0, sizeof buffer_local_flags);
   XSETINT (buffer_local_flags.filename, -1);
   XSETINT (buffer_local_flags.directory, -1);
   XSETINT (buffer_local_flags.backed_up, -1);
diff --git a/src/callint.c b/src/callint.c
index 5716a6fdd47..4a011b55b91 100644
--- a/src/callint.c
+++ b/src/callint.c
@@ -348,8 +348,7 @@ invoke it.  If KEYS is omitted or nil, the return value of
       /* Make a copy of string so that if a GC relocates specs,
          `string' will still be valid.  */
       string = (unsigned char *) alloca (SBYTES (specs) + 1);
-      bcopy (SDATA (specs), string,
-             SBYTES (specs) + 1);
+      memcpy (string, SDATA (specs), SBYTES (specs) + 1);
     }
   else
     {
diff --git a/src/callproc.c b/src/callproc.c
index 34748c71c1c..733cdee3499 100644
--- a/src/callproc.c
+++ b/src/callproc.c
@@ -775,10 +775,8 @@ usage: (call-process PROGRAM &optional INFILE BUFFER DISPLAY &rest ARGS)  */)
                                   PT_BYTE + process_coding.produced);
                 carryover = process_coding.carryover_bytes;
                 if (carryover > 0)
-                  /* As CARRYOVER should not be that large, we had
-                     better avoid overhead of bcopy.  */
-                  BCOPY_SHORT (process_coding.carryover, buf,
-                               process_coding.carryover_bytes);
+                  memcpy (buf, process_coding.carryover,
+                          process_coding.carryover_bytes);
               }
           }
 
@@ -916,7 +914,7 @@ usage: (call-process-region START END PROGRAM &optional DELETE BUFFER DISPLAY &r
 
   pattern = Fexpand_file_name (Vtemp_file_name_pattern, tmpdir);
   tempfile = (char *) alloca (SBYTES (pattern) + 1);
-  bcopy (SDATA (pattern), tempfile, SBYTES (pattern) + 1);
+  memcpy (tempfile, SDATA (pattern), SBYTES (pattern) + 1);
   coding_systems = Qt;
 
 #ifdef HAVE_MKSTEMP
@@ -1099,8 +1097,8 @@ child_setup (int in, int out, int err, register char **new_argv, int set_pgrp, L
     pwd_var = (char *) alloca (i + 6);
 #endif
     temp = pwd_var + 4;
-    bcopy ("PWD=", pwd_var, 4);
-    bcopy (SDATA (current_dir), temp, i);
+    memcpy (pwd_var, "PWD=", 4);
+    memcpy (temp, SDATA (current_dir), i);
     if (!IS_DIRECTORY_SEP (temp[i - 1])) temp[i++] = DIRECTORY_SEP;
     temp[i] = 0;
 
@@ -1325,7 +1323,7 @@ getenv_internal_1 (char *var, int varlen, char **value, int *valuelen, Lisp_Obje
           /* NT environment variables are case insensitive.  */
           && ! strnicmp (SDATA (entry), var, varlen)
 #else  /* not WINDOWSNT */
-          && ! bcmp (SDATA (entry), var, varlen)
+          && ! memcmp (SDATA (entry), var, varlen)
 #endif /* not WINDOWSNT */
           )
         {
diff --git a/src/casefiddle.c b/src/casefiddle.c
index 36715848941..b9667efe2bb 100644
--- a/src/casefiddle.c
+++ b/src/casefiddle.c
@@ -128,7 +128,7 @@ casify_object (enum case_action flag, Lisp_Object obj)
               unsigned char *old_dst = dst;
               o_size += o_size; /* Probably overkill, but extremely rare.  */
               SAFE_ALLOCA (dst, void *, o_size);
-              bcopy (old_dst, dst, o - old_dst);
+              memcpy (dst, old_dst, o - old_dst);
               o = dst + (o - old_dst);
             }
           c = STRING_CHAR_AND_LENGTH (SDATA (obj) + i_byte, len);
diff --git a/src/ccl.c b/src/ccl.c
index 4ddc56a707f..d02e83db8f4 100644
--- a/src/ccl.c
+++ b/src/ccl.c
@@ -1715,7 +1715,7 @@ ccl_driver (struct ccl_program *ccl, int *source, int *destination, int src_size
             msglen = strlen (msg);
             if (dst + msglen <= (dst_bytes ? dst_end : src))
               {
-                bcopy (msg, dst, msglen);
+                memcpy (dst, msg, msglen);
                 dst += msglen;
               }
 
@@ -1728,7 +1728,7 @@ ccl_driver (struct ccl_program *ccl, int *source, int *destination, int src_size
                 msglen = strlen (msg);
                 if (dst + msglen > (dst_bytes ? dst_end : src))
                   break;
-                bcopy (msg, dst, msglen);
+                memcpy (dst, msg, msglen);
                 dst += msglen;
               }
             goto ccl_finish;
@@ -1761,7 +1761,7 @@ ccl_driver (struct ccl_program *ccl, int *source, int *destination, int src_size
           int i = src_end - src;
           if (dst_bytes && (dst_end - dst) < i)
             i = dst_end - dst;
-          bcopy (src, dst, i);
+          memcpy (dst, src, i);
           src += i;
           dst += i;
 #else
diff --git a/src/character.c b/src/character.c
index a6c38df9e85..648c5a291d2 100644
--- a/src/character.c
+++ b/src/character.c
@@ -668,7 +668,7 @@ str_as_multibyte (unsigned char *str, int len, int nbytes, int *nchars)
   to = p;
   nbytes = endp - p;
   endp = str + len;
-  safe_bcopy ((char *) p, (char *) (endp - nbytes), nbytes);
+  memmove (endp - nbytes, p, nbytes);
   p = endp - nbytes;
 
   if (nbytes >= MAX_MULTIBYTE_LENGTH)
@@ -746,7 +746,7 @@ str_to_multibyte (unsigned char *str, int len, int bytes)
   to = p;
   bytes = endp - p;
   endp = str + len;
-  safe_bcopy ((char *) p, (char *) (endp - bytes), bytes);
+  memmove (endp - bytes, p, bytes);
   p = endp - bytes;
   while (p < endp)
     {
diff --git a/src/character.h b/src/character.h
index f9d95010655..b32dabba12e 100644
--- a/src/character.h
+++ b/src/character.h
@@ -636,18 +636,6 @@ extern Lisp_Object Vauto_fill_chars;
 extern Lisp_Object Vchar_script_table;
 extern Lisp_Object Vscript_representative_chars;
 
-/* Copy LEN bytes from FROM to TO.  This macro should be used only
-   when a caller knows that LEN is short and the obvious copy loop is
-   faster than calling bcopy which has some overhead.  Copying a
-   multibyte sequence of a character is the typical case.  */
-
-#define BCOPY_SHORT(from, to, len)              \
-  do {                                          \
-    int i = len;                                \
-    unsigned char *from_p = from, *to_p = to;   \
-    while (i--) *to_p++ = *from_p++;            \
-  } while (0)
-
 #define DEFSYM(sym, name)       \
   do { (sym) = intern_c_string ((name)); staticpro (&(sym)); } while (0)
 
diff --git a/src/charset.c b/src/charset.c
index 45ce52870bd..718b5197471 100644
--- a/src/charset.c
+++ b/src/charset.c
@@ -522,7 +522,7 @@ load_charset_map_from_file (struct charset *charset, Lisp_Object mapfile, int co
   SAFE_ALLOCA (head, struct charset_map_entries *,
                sizeof (struct charset_map_entries));
   entries = head;
-  bzero (entries, sizeof (struct charset_map_entries));
+  memset (entries, 0, sizeof (struct charset_map_entries));
 
   n_entries = 0;
   eof = 0;
@@ -549,7 +549,7 @@ load_charset_map_from_file (struct charset *charset, Lisp_Object mapfile, int co
           SAFE_ALLOCA (entries->next, struct charset_map_entries *,
                        sizeof (struct charset_map_entries));
           entries = entries->next;
-          bzero (entries, sizeof (struct charset_map_entries));
+          memset (entries, 0, sizeof (struct charset_map_entries));
         }
       idx = n_entries % 0x10000;
       entries->entry[idx].from = from;
@@ -585,7 +585,7 @@ load_charset_map_from_vector (struct charset *charset, Lisp_Object vec, int cont
   SAFE_ALLOCA (head, struct charset_map_entries *,
                sizeof (struct charset_map_entries));
   entries = head;
-  bzero (entries, sizeof (struct charset_map_entries));
+  memset (entries, 0, sizeof (struct charset_map_entries));
 
   n_entries = 0;
   for (i = 0; i < len; i += 2)
@@ -622,7 +622,7 @@ load_charset_map_from_vector (struct charset *charset, Lisp_Object vec, int cont
           SAFE_ALLOCA (entries->next, struct charset_map_entries *,
                        sizeof (struct charset_map_entries));
           entries = entries->next;
-          bzero (entries, sizeof (struct charset_map_entries));
+          memset (entries, 0, sizeof (struct charset_map_entries));
         }
       idx = n_entries % 0x10000;
       entries->entry[idx].from = from;
@@ -935,7 +935,7 @@ usage: (define-charset-internal ...)  */)
   if (! charset.code_linear_p)
     {
       charset.code_space_mask = (unsigned char *) xmalloc (256);
-      bzero (charset.code_space_mask, 256);
+      memset (charset.code_space_mask, 0, 256);
       for (i = 0; i < 4; i++)
         for (j = charset.code_space[i * 4]; j <= charset.code_space[i * 4 + 1];
              j++)
@@ -1058,7 +1058,7 @@ usage: (define-charset-internal ...)  */)
 
   charset.unified_p = 0;
 
-  bzero (charset.fast_map, sizeof (charset.fast_map));
+  memset (charset.fast_map, 0, sizeof (charset.fast_map));
 
   if (! NILP (args[charset_arg_code_offset]))
     {
@@ -1191,8 +1191,8 @@ usage: (define-charset-internal ...)  */)
           struct charset *new_table
             = (struct charset *) xmalloc (sizeof (struct charset)
                                           * (charset_table_size + 16));
-          bcopy (charset_table, new_table,
-                 sizeof (struct charset) * charset_table_size);
+          memcpy (new_table, charset_table,
+                  sizeof (struct charset) * charset_table_size);
           charset_table_size += 16;
           charset_table = new_table;
         }
diff --git a/src/cm.c b/src/cm.c
index c2a68ed7015..dac6ece7b2d 100644
--- a/src/cm.c
+++ b/src/cm.c
@@ -430,7 +430,7 @@ cmgoto (struct tty_display_info *tty, int row, int col)
 void
 Wcm_clear (struct tty_display_info *tty)
 {
-  bzero (tty->Wcm, sizeof (struct cm));
+  memset (tty->Wcm, 0, sizeof (struct cm));
   UP = 0;
   BC = 0;
 }
diff --git a/src/coding.c b/src/coding.c
index f16d505b67a..989fd70b497 100644
--- a/src/coding.c
+++ b/src/coding.c
@@ -6550,7 +6550,7 @@ decode_eol (struct coding_system *coding)
           for (p = pend - 2; p >= pbeg; p--)
             if (*p == '\r')
               {
-                safe_bcopy ((char *) (p + 1), (char *) p, pend-- - p - 1);
+                memmove (p, p + 1, pend-- - p - 1);
                 n++;
               }
         }
@@ -7814,7 +7814,7 @@ decode_coding_object (struct coding_system *coding,
             }
           if (BEGV < GPT && GPT < BEGV + coding->produced_char)
             move_gap_both (BEGV, BEGV_BYTE);
-          bcopy (BEGV_ADDR, destination, coding->produced);
+          memcpy (destination, BEGV_ADDR, coding->produced);
           coding->destination = destination;
         }
     }
@@ -9482,7 +9482,7 @@ usage: (set-coding-system-priority &rest coding-systems)  */)
   int changed[coding_category_max];
   enum coding_category priorities[coding_category_max];
 
-  bzero (changed, sizeof changed);
+  memset (changed, 0, sizeof changed);
 
   for (i = j = 0; i < nargs; i++)
     {
@@ -9517,7 +9517,7 @@ usage: (set-coding-system-priority &rest coding-systems)  */)
       priorities[i] = coding_priorities[j];
     }
 
-  bcopy (priorities, coding_priorities, sizeof priorities);
+  memcpy (coding_priorities, priorities, sizeof priorities);
 
   /* Update `coding-category-list'.  */
   Vcoding_category_list = Qnil;
@@ -9568,11 +9568,11 @@ make_subsidiaries (Lisp_Object base)
   char *buf = (char *) alloca (base_name_len + 6);
   int i;
 
-  bcopy (SDATA (SYMBOL_NAME (base)), buf, base_name_len);
+  memcpy (buf, SDATA (SYMBOL_NAME (base)), base_name_len);
   subsidiaries = Fmake_vector (make_number (3), Qnil);
   for (i = 0; i < 3; i++)
     {
-      bcopy (suffixes[i], buf + base_name_len, strlen (suffixes[i]) + 1);
+      memcpy (buf + base_name_len, suffixes[i], strlen (suffixes[i]) + 1);
       ASET (subsidiaries, i, intern (buf));
     }
   return subsidiaries;
diff --git a/src/config.in b/src/config.in
index e2328dd9384..1ef407c158b 100644
--- a/src/config.in
+++ b/src/config.in
@@ -102,15 +102,6 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 /* Define to 1 if ALSA is available. */
 #undef HAVE_ALSA
 
-/* Define to 1 if you have the `bcmp' function. */
-#undef HAVE_BCMP
-
-/* Define to 1 if you have the `bcopy' function. */
-#undef HAVE_BCOPY
-
-/* Define to 1 if you have the `bzero' function. */
-#undef HAVE_BZERO
-
 /* Define to 1 if you have the `cbrt' function. */
 #undef HAVE_CBRT
 
@@ -1141,10 +1132,6 @@ SYSTEM_PURESIZE_EXTRA seems like the least likely to cause problems.  */
 #include <string.h>
 #endif
 
-#ifdef HAVE_STRINGS_H
-#include <strings.h>  /* May be needed for bcopy & al.  */
-#endif
-
 #ifdef HAVE_STDLIB_H
 #include <stdlib.h>
 #endif
@@ -1186,16 +1173,6 @@ typedef unsigned size_t;
 #  endif
 #endif
 
-#ifndef HAVE_BCOPY
-#define bcopy(a,b,s) memcpy (b,a,s)
-#endif
-#ifndef HAVE_BZERO
-#define bzero(a,s) memset (a,0,s)
-#endif
-#ifndef HAVE_BCMP
-#define BCMP memcmp
-#endif
-
 #endif /* EMACS_CONFIG_H */
 
 /*
diff --git a/src/data.c b/src/data.c
index 3949e6da54b..cde6e9538b9 100644
--- a/src/data.c
+++ b/src/data.c
@@ -2264,13 +2264,13 @@ bool-vector.  IDX starts at 0.  */)
           USE_SAFE_ALLOCA;
 
           SAFE_ALLOCA (str, unsigned char *, nbytes);
-          bcopy (SDATA (array), str, nbytes);
+          memcpy (str, SDATA (array), nbytes);
           allocate_string_data (XSTRING (array), nchars,
                                 nbytes + new_bytes - prev_bytes);
-          bcopy (str, SDATA (array), idxval_byte);
+          memcpy (SDATA (array), str, idxval_byte);
           p1 = SDATA (array) + idxval_byte;
-          bcopy (str + idxval_byte + prev_bytes, p1 + new_bytes,
-                 nbytes - (idxval_byte + prev_bytes));
+          memcpy (p1 + new_bytes, str + idxval_byte + prev_bytes,
+                  nbytes - (idxval_byte + prev_bytes));
           SAFE_FREE ();
           clear_string_char_byte_cache ();
         }
diff --git a/src/dired.c b/src/dired.c
index a24d068d3b6..cbff34302b9 100644
--- a/src/dired.c
+++ b/src/dired.c
@@ -289,15 +289,14 @@ directory_files_internal (Lisp_Object directory, Lisp_Object full, Lisp_Object m
                   int nchars;
 
                   fullname = make_uninit_multibyte_string (nbytes, nbytes);
-                  bcopy (SDATA (directory), SDATA (fullname),
-                         directory_nbytes);
+                  memcpy (SDATA (fullname), SDATA (directory),
+                          directory_nbytes);
 
                   if (needsep)
                     SSET (fullname, directory_nbytes, DIRECTORY_SEP);
 
-                  bcopy (SDATA (name),
-                         SDATA (fullname) + directory_nbytes + needsep,
-                         len);
+                  memcpy (SDATA (fullname) + directory_nbytes + needsep,
+                          SDATA (name), len);
 
                   nchars = chars_in_text (SDATA (fullname), nbytes);
 
@@ -857,11 +856,11 @@ file_name_completion_stat (Lisp_Object dirname, DIRENTRY *dp, struct stat *st_ad
   _djstat_flags = _STAT_INODE | _STAT_EXEC_MAGIC | _STAT_DIRSIZE;
 #endif /* MSDOS */
 
-  bcopy (SDATA (dirname), fullname, pos);
+  memcpy (fullname, SDATA (dirname), pos);
   if (!IS_DIRECTORY_SEP (fullname[pos - 1]))
     fullname[pos++] = DIRECTORY_SEP;
 
-  bcopy (dp->d_name, fullname + pos, len);
+  memcpy (fullname + pos, dp->d_name, len);
   fullname[pos + len] = 0;
 
 #ifdef S_IFLNK
diff --git a/src/dispnew.c b/src/dispnew.c
index 2bfec21f3f2..7c0009e570a 100644
--- a/src/dispnew.c
+++ b/src/dispnew.c
@@ -436,62 +436,15 @@ DEFUN ("dump-redisplay-history", Fdump_redisplay_history,
 #endif /* GLYPH_DEBUG == 0 */
 
 
-/* Like bcopy except never gets confused by overlap.  Let this be the
-   first function defined in this file, or change emacs.c where the
-   address of this function is used.  */
+#ifdef PROFILING
+/* FIXME: only used to find text start for profiling.  */
 
 void
 safe_bcopy (const char *from, char *to, int size)
 {
-  if (size <= 0 || from == to)
-    return;
-
-  /* If the source and destination don't overlap, then bcopy can
-     handle it.  If they do overlap, but the destination is lower in
-     memory than the source, we'll assume bcopy can handle that.  */
-  if (to < from || from + size <= to)
-    bcopy (from, to, size);
-
-  /* Otherwise, we'll copy from the end.  */
-  else
-    {
-      register const char *endf = from + size;
-      register char *endt = to + size;
-
-      /* If TO - FROM is large, then we should break the copy into
-         nonoverlapping chunks of TO - FROM bytes each.  However, if
-         TO - FROM is small, then the bcopy function call overhead
-         makes this not worth it.  The crossover point could be about
-         anywhere.  Since I don't think the obvious copy loop is too
-         bad, I'm trying to err in its favor.  */
-      if (to - from < 64)
-        {
-          do
-            *--endt = *--endf;
-          while (endf != from);
-        }
-      else
-        {
-          for (;;)
-            {
-              endt -= (to - from);
-              endf -= (to - from);
-
-              if (endt < to)
-                break;
-
-              bcopy (endf, endt, to - from);
-            }
-
-          /* If SIZE wasn't a multiple of TO - FROM, there will be a
-             little left over.  The amount left over is (endt + (to -
-             from)) - to, which is endt - from.  */
-          bcopy (from, to, endt - from);
-        }
-    }
+  abort ();
 }
-
-
+#endif
 
 /***********************************************************************
                             Glyph Matrices
@@ -510,7 +463,7 @@ new_glyph_matrix (struct glyph_pool *pool)
 
   /* Allocate and clear.  */
   result = (struct glyph_matrix *) xmalloc (sizeof *result);
-  bzero (result, sizeof *result);
+  memset (result, 0, sizeof *result);
 
   /* Increment number of allocated matrices.  This count is used
      to detect memory leaks.  */
@@ -655,8 +608,8 @@ adjust_glyph_matrix (struct window *w, struct glyph_matrix *matrix, int x, int y
       int size = dim.height * sizeof (struct glyph_row);
       new_rows = dim.height - matrix->rows_allocated;
       matrix->rows = (struct glyph_row *) xrealloc (matrix->rows, size);
-      bzero (matrix->rows + matrix->rows_allocated,
-             new_rows * sizeof *matrix->rows);
+      memset (matrix->rows + matrix->rows_allocated, 0,
+              new_rows * sizeof *matrix->rows);
       matrix->rows_allocated = dim.height;
     }
   else
@@ -1103,7 +1056,7 @@ clear_glyph_row (struct glyph_row *row)
          returned by xmalloc.  If flickering happens again, activate
          the code below.  If the flickering is gone with that, chances
          are that the flickering has the same reason as here.  */
-  bzero (p[0], (char *) p[LAST_AREA] - (char *) p[0]);
+  memset (p[0], 0, (char *) p[LAST_AREA] - (char *) p[0]);
 #endif
 }
 
@@ -1237,13 +1190,13 @@ copy_row_except_pointers (struct glyph_row *to, struct glyph_row *from)
   struct glyph *pointers[1 + LAST_AREA];
 
   /* Save glyph pointers of TO.  */
-  bcopy (to->glyphs, pointers, sizeof to->glyphs);
+  memcpy (pointers, to->glyphs, sizeof to->glyphs);
 
   /* Do a structure assignment.  */
   *to = *from;
 
   /* Restore original pointers of TO.  */
-  bcopy (pointers, to->glyphs, sizeof to->glyphs);
+  memcpy (to->glyphs, pointers, sizeof to->glyphs);
 }
 
 
@@ -1264,8 +1217,8 @@ copy_glyph_row_contents (struct glyph_row *to, struct glyph_row *from, int delta
   /* Copy glyphs from FROM to TO.  */
   for (area = 0; area < LAST_AREA; ++area)
     if (from->used[area])
-      bcopy (from->glyphs[area], to->glyphs[area],
-             from->used[area] * sizeof (struct glyph));
+      memcpy (to->glyphs[area], from->glyphs[area],
+              from->used[area] * sizeof (struct glyph));
 
   /* Increment buffer positions in TO by DELTA.  */
   increment_row_positions (to, delta, delta_bytes);
@@ -1524,7 +1477,7 @@ new_glyph_pool (void)
 
   /* Allocate a new glyph_pool and clear it.  */
   result = (struct glyph_pool *) xmalloc (sizeof *result);
-  bzero (result, sizeof *result);
+  memset (result, 0, sizeof *result);
 
   /* For memory leak and double deletion checking.  */
   ++glyph_pool_count;
@@ -1585,7 +1538,7 @@ realloc_glyph_pool (struct glyph_pool *pool, struct dim matrix_dim)
       else
         {
           pool->glyphs = (struct glyph *) xmalloc (size);
-          bzero (pool->glyphs, size);
+          memset (pool->glyphs, 0, size);
         }
 
       pool->nglyphs = needed;
@@ -2196,11 +2149,11 @@ save_current_matrix (struct frame *f)
   struct glyph_matrix *saved;
 
   saved = (struct glyph_matrix *) xmalloc (sizeof *saved);
-  bzero (saved, sizeof *saved);
+  memset (saved, 0, sizeof *saved);
   saved->nrows = f->current_matrix->nrows;
   saved->rows = (struct glyph_row *) xmalloc (saved->nrows
                                               * sizeof *saved->rows);
-  bzero (saved->rows, saved->nrows * sizeof *saved->rows);
+  memset (saved->rows, 0, saved->nrows * sizeof *saved->rows);
 
   for (i = 0; i < saved->nrows; ++i)
     {
@@ -2208,7 +2161,7 @@ save_current_matrix (struct frame *f)
       struct glyph_row *to = saved->rows + i;
       size_t nbytes = from->used[TEXT_AREA] * sizeof (struct glyph);
       to->glyphs[TEXT_AREA] = (struct glyph *) xmalloc (nbytes);
-      bcopy (from->glyphs[TEXT_AREA], to->glyphs[TEXT_AREA], nbytes);
+      memcpy (to->glyphs[TEXT_AREA], from->glyphs[TEXT_AREA], nbytes);
       to->used[TEXT_AREA] = from->used[TEXT_AREA];
     }
 
@@ -2229,7 +2182,7 @@ restore_current_matrix (struct frame *f, struct glyph_matrix *saved)
       struct glyph_row *from = saved->rows + i;
       struct glyph_row *to = f->current_matrix->rows + i;
       size_t nbytes = from->used[TEXT_AREA] * sizeof (struct glyph);
-      bcopy (from->glyphs[TEXT_AREA], to->glyphs[TEXT_AREA], nbytes);
+      memcpy (to->glyphs[TEXT_AREA], from->glyphs[TEXT_AREA], nbytes);
       to->used[TEXT_AREA] = from->used[TEXT_AREA];
       xfree (from->glyphs[TEXT_AREA]);
     }
@@ -2740,9 +2693,9 @@ build_frame_matrix_from_leaf_window (struct glyph_matrix *frame_matrix, struct w
       if (current_row_p)
         {
           /* Copy window row to frame row.  */
-          bcopy (window_row->glyphs[0],
-                 frame_row->glyphs[TEXT_AREA] + window_matrix->matrix_x,
-                 window_matrix->matrix_w * sizeof (struct glyph));
+          memcpy (frame_row->glyphs[TEXT_AREA] + window_matrix->matrix_x,
+                  window_row->glyphs[0],
+                  window_matrix->matrix_w * sizeof (struct glyph));
         }
       else
         {
@@ -2979,7 +2932,7 @@ mirrored_line_dance (matrix, unchanged_at_top, nlines, copy_from,
 
   /* Make a copy of the original rows.  */
   old_rows = (struct glyph_row *) alloca (nlines * sizeof *old_rows);
-  bcopy (new_rows, old_rows, nlines * sizeof *old_rows);
+  memcpy (old_rows, new_rows, nlines * sizeof *old_rows);
 
   /* Assign new rows, maybe clear lines.  */
   for (i = 0; i < nlines; ++i)
@@ -3097,7 +3050,7 @@ mirror_line_dance (struct window *w, int unchanged_at_top, int nlines, int *copy
 
           /* Make a copy of the original rows of matrix m.  */
           old_rows = (struct glyph_row *) alloca (m->nrows * sizeof *old_rows);
-          bcopy (m->rows, old_rows, m->nrows * sizeof *old_rows);
+          memcpy (old_rows, m->rows, m->nrows * sizeof *old_rows);
 
           for (i = 0; i < nlines; ++i)
             {
@@ -4563,7 +4516,7 @@ scrolling_window (struct window *w, int header_line_p)
       row_table_size = next_almost_prime (3 * n);
       nbytes = row_table_size * sizeof *row_table;
       row_table = (struct row_entry **) xrealloc (row_table, nbytes);
-      bzero (row_table, nbytes);
+      memset (row_table, 0, nbytes);
     }
 
   if (n > row_entry_pool_size)
diff --git a/src/doc.c b/src/doc.c
index 57e1bc8f0e6..ce4c1ddda6a 100644
--- a/src/doc.c
+++ b/src/doc.c
@@ -686,7 +686,7 @@ the same file name is found in the `doc-directory'.  */)
         }
       pos += end - buf;
       filled -= end - buf;
-      bcopy (end, buf, filled);
+      memcpy (buf, end, filled);
     }
   emacs_close (fd);
   return Qnil;
@@ -765,7 +765,7 @@ a new string, without any text properties, is returned.  */)
               if (len == 1)
                 *bufp = *strp;
               else
-                bcopy (strp, bufp, len);
+                memcpy (bufp, strp, len);
               strp += len;
               bufp += len;
               nchars++;
@@ -817,7 +817,7 @@ a new string, without any text properties, is returned.  */)
               int offset = bufp - buf;
               buf = (unsigned char *) xrealloc (buf, bsize += 4);
               bufp = buf + offset;
-              bcopy ("M-x ", bufp, 4);
+              memcpy (bufp, "M-x ", 4);
               bufp += 4;
               nchars += 4;
               if (multibyte)
@@ -911,7 +911,7 @@ a new string, without any text properties, is returned.  */)
             int offset = bufp - buf;
             buf = (unsigned char *) xrealloc (buf, bsize += length_byte);
             bufp = buf + offset;
-            bcopy (start, bufp, length_byte);
+            memcpy (bufp, start, length_byte);
             bufp += length_byte;
             nchars += length;
             /* Check STRING again in case gc relocated it.  */
@@ -928,7 +928,7 @@ a new string, without any text properties, is returned.  */)
           if (len == 1)
             *bufp = *strp;
           else
-            bcopy (strp, bufp, len);
+            memcpy (bufp, strp, len);
           strp += len;
           bufp += len;
           nchars++;
diff --git a/src/doprnt.c b/src/doprnt.c
index f747d3a0281..3ff2f70dd34 100644
--- a/src/doprnt.c
+++ b/src/doprnt.c
@@ -229,12 +229,12 @@ doprnt (char *buffer, register int bufsize, char *format, char *format_end, int
                   /* Truncate the string at character boundary.  */
                   tem = bufsize;
                   while (!CHAR_HEAD_P (string[tem - 1])) tem--;
-                  bcopy (string, bufptr, tem);
+                  memcpy (bufptr, string, tem);
                   /* We must calculate WIDTH again.  */
                   width = strwidth (bufptr, tem);
                 }
               else
-                bcopy (string, bufptr, tem);
+                memcpy (bufptr, string, tem);
               bufptr += tem;
               bufsize -= tem;
               if (minlen < 0)
diff --git a/src/editfns.c b/src/editfns.c
index 5b340644fa8..ba27d4a76e0 100644
--- a/src/editfns.c
+++ b/src/editfns.c
@@ -1405,7 +1405,7 @@ name, or nil if there is no such user.  */)
 
       login = Fuser_login_name (make_number (pw->pw_uid));
       r = (unsigned char *) alloca (strlen (p) + SCHARS (login) + 1);
-      bcopy (p, r, q - p);
+      memcpy (r, p, q - p);
       r[q - p] = 0;
       strcat (r, SDATA (login));
       r[q - p] = UPCASE (r[q - p]);
@@ -2418,8 +2418,7 @@ make_buffer_string_both (int start, int start_byte, int end, int end_byte, int p
     result = make_uninit_multibyte_string (end - start, end_byte - start_byte);
   else
     result = make_uninit_string (end - start);
-  bcopy (BYTE_POS_ADDR (start_byte), SDATA (result),
-         end_byte - start_byte);
+  memcpy (SDATA (result), BYTE_POS_ADDR (start_byte), end_byte - start_byte);
 
   /* If desired, update and copy the text properties.  */
   if (props)
@@ -3437,7 +3436,7 @@ usage: (message-box FORMAT-STRING &rest ARGS)  */)
           message_length = SBYTES (val);
           message_text = (char *)xrealloc (message_text, message_length);
         }
-      bcopy (SDATA (val), message_text, SBYTES (val));
+      memcpy (message_text, SDATA (val), SBYTES (val));
       message2 (message_text, SBYTES (val),
                 STRING_MULTIBYTE (val));
       return val;
@@ -3654,12 +3653,12 @@ usage: (format STRING &rest OBJECTS)  */)
     int i;
     if (!info)
       info = (struct info *) alloca (nbytes);
-    bzero (info, nbytes);
+    memset (info, 0, nbytes);
     for (i = 0; i <= nargs; i++)
       info[i].start = -1;
     if (!discarded)
       SAFE_ALLOCA (discarded, char *, SBYTES (args[0]));
-    bzero (discarded, SBYTES (args[0]));
+    memset (discarded, 0, SBYTES (args[0]));
   }
 
   /* Add to TOTAL enough space to hold the converted arguments.  */
@@ -3973,8 +3972,8 @@ usage: (format STRING &rest OBJECTS)  */)
             {
               int this_nchars;
 
-              bcopy (this_format_start, this_format,
-                     format - this_format_start);
+              memcpy (this_format, this_format_start,
+                      format - this_format_start);
               this_format[format - this_format_start] = 0;
 
               if (format[-1] == 'e' || format[-1] == 'f' || format[-1] == 'g')
@@ -4451,9 +4450,9 @@ Transposing beyond buffer boundaries is an error.  */)
           start1_addr = BYTE_POS_ADDR (start1_byte);
           start2_addr = BYTE_POS_ADDR (start2_byte);
 
-          bcopy (start2_addr, temp, len2_byte);
-          bcopy (start1_addr, start1_addr + len2_byte, len1_byte);
-          bcopy (temp, start1_addr, len2_byte);
+          memcpy (temp, start2_addr, len2_byte);
+          memcpy (start1_addr + len2_byte, start1_addr, len1_byte);
+          memcpy (start1_addr, temp, len2_byte);
           SAFE_FREE ();
         }
       else
@@ -4464,9 +4463,9 @@ Transposing beyond buffer boundaries is an error.  */)
           SAFE_ALLOCA (temp, unsigned char *, len1_byte);
           start1_addr = BYTE_POS_ADDR (start1_byte);
           start2_addr = BYTE_POS_ADDR (start2_byte);
-          bcopy (start1_addr, temp, len1_byte);
-          bcopy (start2_addr, start1_addr, len2_byte);
-          bcopy (temp, start1_addr + len2_byte, len1_byte);
+          memcpy (temp, start1_addr, len1_byte);
+          memcpy (start1_addr, start2_addr, len2_byte);
+          memcpy (start1_addr + len2_byte, temp, len1_byte);
           SAFE_FREE ();
         }
       graft_intervals_into_buffer (tmp_interval1, start1 + len2,
@@ -4504,9 +4503,9 @@ Transposing beyond buffer boundaries is an error.  */)
           SAFE_ALLOCA (temp, unsigned char *, len1_byte);
           start1_addr = BYTE_POS_ADDR (start1_byte);
           start2_addr = BYTE_POS_ADDR (start2_byte);
-          bcopy (start1_addr, temp, len1_byte);
-          bcopy (start2_addr, start1_addr, len2_byte);
-          bcopy (temp, start2_addr, len1_byte);
+          memcpy (temp, start1_addr, len1_byte);
+          memcpy (start1_addr, start2_addr, len2_byte);
+          memcpy (start2_addr, temp, len1_byte);
           SAFE_FREE ();
 
           graft_intervals_into_buffer (tmp_interval1, start2,
@@ -4534,10 +4533,10 @@ Transposing beyond buffer boundaries is an error.  */)
           SAFE_ALLOCA (temp, unsigned char *, len2_byte);
           start1_addr = BYTE_POS_ADDR (start1_byte);
           start2_addr = BYTE_POS_ADDR (start2_byte);
-          bcopy (start2_addr, temp, len2_byte);
-          bcopy (start1_addr, start1_addr + len_mid + len2_byte, len1_byte);
-          safe_bcopy (start1_addr + len1_byte, start1_addr + len2_byte, len_mid);
-          bcopy (temp, start1_addr, len2_byte);
+          memcpy (temp, start2_addr, len2_byte);
+          memcpy (start1_addr + len_mid + len2_byte, start1_addr, len1_byte);
+          memmove (start1_addr + len2_byte, start1_addr + len1_byte, len_mid);
+          memcpy (start1_addr, temp, len2_byte);
           SAFE_FREE ();
 
           graft_intervals_into_buffer (tmp_interval1, end2 - len1,
@@ -4567,10 +4566,10 @@ Transposing beyond buffer boundaries is an error.  */)
           SAFE_ALLOCA (temp, unsigned char *, len1_byte);
           start1_addr = BYTE_POS_ADDR (start1_byte);
           start2_addr = BYTE_POS_ADDR (start2_byte);
-          bcopy (start1_addr, temp, len1_byte);
-          bcopy (start2_addr, start1_addr, len2_byte);
-          bcopy (start1_addr + len1_byte, start1_addr + len2_byte, len_mid);
-          bcopy (temp, start1_addr + len2_byte + len_mid, len1_byte);
+          memcpy (temp, start1_addr, len1_byte);
+          memcpy (start1_addr, start2_addr, len2_byte);
+          memcpy (start1_addr + len2_byte, start1_addr + len1_byte, len_mid);
+          memcpy (start1_addr + len2_byte + len_mid, temp, len1_byte);
           SAFE_FREE ();
 
           graft_intervals_into_buffer (tmp_interval1, end2 - len1,
diff --git a/src/emacs.c b/src/emacs.c
index 79604413beb..cccfb02f1ef 100644
--- a/src/emacs.c
+++ b/src/emacs.c
@@ -1761,13 +1761,14 @@ main (int argc, char **argv)
       extern char etext;
 #endif
       extern void safe_bcopy ();
-      extern void dump_opcode_frequencies ();
 
       atexit (_mcleanup);
       /* This uses safe_bcopy because that function comes first in the
          Emacs executable.  It might be better to use something that
          gives the start of the text segment, but start_of_text is not
          defined on all systems now.  */
+      /* FIXME: Does not work on architectures with function
+         descriptors.  */
       monstartup (safe_bcopy, &etext);
     }
   else
@@ -2058,7 +2059,7 @@ sort_args (int argc, char **argv)
   while (to < argc)
     new[to++] = 0;
 
-  bcopy (new, argv, sizeof (char *) * argc);
+  memcpy (argv, new, sizeof (char *) * argc);
 
   xfree (options);
   xfree (new);
diff --git a/src/eval.c b/src/eval.c
index d7e19139c6e..47c46fcbfdf 100644
--- a/src/eval.c
+++ b/src/eval.c
@@ -2529,7 +2529,7 @@ usage: (apply FUNCTION &rest ARGUMENTS)  */)
       gcpro1.nvars = 1 + numargs;
     }
 
-  bcopy (args, funcall_args, nargs * sizeof (Lisp_Object));
+  memcpy (funcall_args, args, nargs * sizeof (Lisp_Object));
   /* Spread the last arg we got.  Its first element goes in
      the slot that it used to occupy, hence this value of I.  */
   i = nargs - 1;
@@ -3018,7 +3018,7 @@ usage: (funcall FUNCTION &rest ARGUMENTS)  */)
       if (XSUBR (fun)->max_args > numargs)
         {
           internal_args = (Lisp_Object *) alloca (XSUBR (fun)->max_args * sizeof (Lisp_Object));
-          bcopy (args + 1, internal_args, numargs * sizeof (Lisp_Object));
+          memcpy (internal_args, args + 1, numargs * sizeof (Lisp_Object));
           for (i = numargs; i < XSUBR (fun)->max_args; i++)
             internal_args[i] = Qnil;
         }
diff --git a/src/fileio.c b/src/fileio.c
index 525d6ebf4a8..ee2dc9fa52a 100644
--- a/src/fileio.c
+++ b/src/fileio.c
@@ -425,7 +425,7 @@ Given a Unix syntax file name, returns a string ending in slash.  */)
   filename = FILE_SYSTEM_CASE (filename);
 #ifdef DOS_NT
   beg = (unsigned char *) alloca (SBYTES (filename) + 1);
-  bcopy (SDATA (filename), beg, SBYTES (filename) + 1);
+  memcpy (beg, SDATA (filename), SBYTES (filename) + 1);
 #else
   beg = SDATA (filename);
 #endif
@@ -725,10 +725,10 @@ make_temp_name (Lisp_Object prefix, int base64_p)
   if (!STRING_MULTIBYTE (prefix))
     STRING_SET_UNIBYTE (val);
   data = SDATA (val);
-  bcopy(SDATA (prefix), data, len);
+  memcpy (data, SDATA (prefix), len);
   p = data + len;
 
-  bcopy (pidbuf, p, pidlen);
+  memcpy (p, pidbuf, pidlen);
   p += pidlen;
 
   /* Here we try to minimize useless stat'ing when this function is
@@ -939,7 +939,7 @@ filesystem tree, not (expand-file-name ".."  dirname).  */)
 
   /* Make a local copy of nm[] to protect it from GC in DECODE_FILE below. */
   nm = (unsigned char *) alloca (SBYTES (name) + 1);
-  bcopy (SDATA (name), nm, SBYTES (name) + 1);
+  memcpy (nm, SDATA (name), SBYTES (name) + 1);
 
 #ifdef DOS_NT
   /* Note if special escape prefix is present, but remove for now.  */
@@ -1093,7 +1093,7 @@ filesystem tree, not (expand-file-name ".."  dirname).  */)
           unsigned char *o, *p;
           for (p = nm; *p && (!IS_DIRECTORY_SEP (*p)); p++);
           o = alloca (p - nm + 1);
-          bcopy ((char *) nm, o, p - nm);
+          memcpy (o, nm, p - nm);
           o [p - nm] = 0;
 
           BLOCK_INPUT;
@@ -1244,7 +1244,7 @@ filesystem tree, not (expand-file-name ".."  dirname).  */)
           )
         {
           unsigned char *temp = (unsigned char *) alloca (length);
-          bcopy (newdir, temp, length - 1);
+          memcpy (temp, newdir, length - 1);
           temp[length - 1] = 0;
           newdir = temp;
         }
@@ -1467,7 +1467,7 @@ See also the function `substitute-in-file-name'.")
         int len = ptr ? ptr - user : strlen (user);
         /* Copy the user name into temp storage. */
         o = (unsigned char *) alloca (len + 1);
-        bcopy ((char *) user, o, len);
+        memcpy (o, user, len);
         o[len] = 0;
 
         /* Look up the user name. */
@@ -1583,7 +1583,7 @@ search_embedded_absfilename (unsigned char *nm, unsigned char *endp)
             {
               unsigned char *o = alloca (s - p + 1);
               struct passwd *pw;
-              bcopy (p, o, s - p);
+              memcpy (o, p, s - p);
               o [s - p] = 0;
 
               /* If we have ~user and `user' exists, discard
@@ -1640,7 +1640,7 @@ those `/' is discarded.  */)
      decode of environment variables, causing the original Lisp_String
      data to be relocated.  */
   nm = (unsigned char *) alloca (SBYTES (filename) + 1);
-  bcopy (SDATA (filename), nm, SBYTES (filename) + 1);
+  memcpy (nm, SDATA (filename), SBYTES (filename) + 1);
 
 #ifdef DOS_NT
   dostounix_filename (nm);
@@ -2733,7 +2733,7 @@ points to a nonexistent file.  */)
     {
       bufsize *= 2;
       buf = (char *) xrealloc (buf, bufsize);
-      bzero (buf, bufsize);
+      memset (buf, 0, bufsize);
 
       errno = 0;
       valsize = readlink (SDATA (filename), buf, bufsize);
@@ -3837,7 +3837,7 @@ variable `last-coding-system-used' to the coding system actually used.  */)
                                   conversion_buffer);
           unprocessed = coding.carryover_bytes;
           if (coding.carryover_bytes > 0)
-            bcopy (coding.carryover, read_buf, unprocessed);
+            memcpy (read_buf, coding.carryover, unprocessed);
         }
       UNGCPRO;
       emacs_close (fd);
@@ -5245,7 +5245,7 @@ auto_save_error (Lisp_Object error)
   GCPRO1 (msg);
   nbytes = SBYTES (msg);
   SAFE_ALLOCA (msgbuf, char *, nbytes);
-  bcopy (SDATA (msg), msgbuf, nbytes);
+  memcpy (msgbuf, SDATA (msg), nbytes);
 
   for (i = 0; i < 3; ++i)
     {
diff --git a/src/fns.c b/src/fns.c
index a6f80f33153..240c0834800 100644
--- a/src/fns.c
+++ b/src/fns.c
@@ -233,7 +233,7 @@ Symbols are also allowed; their print names are used instead.  */)
 
   if (SCHARS (s1) != SCHARS (s2)
       || SBYTES (s1) != SBYTES (s2)
-      || bcmp (SDATA (s1), SDATA (s2), SBYTES (s1)))
+      || memcmp (SDATA (s1), SDATA (s2), SBYTES (s1)))
     return Qnil;
   return Qt;
 }
@@ -469,8 +469,8 @@ with the original.  */)
            / BOOL_VECTOR_BITS_PER_CHAR);
 
       val = Fmake_bool_vector (Flength (arg), Qnil);
-      bcopy (XBOOL_VECTOR (arg)->data, XBOOL_VECTOR (val)->data,
-             size_in_chars);
+      memcpy (XBOOL_VECTOR (val)->data, XBOOL_VECTOR (arg)->data,
+              size_in_chars);
       return val;
     }
 
@@ -637,8 +637,7 @@ concat (int nargs, Lisp_Object *args, enum Lisp_Type target_type, int last_speci
         {
           int thislen_byte = SBYTES (this);
 
-          bcopy (SDATA (this), SDATA (val) + toindex_byte,
-                 SBYTES (this));
+          memcpy (SDATA (val) + toindex_byte, SDATA (this), SBYTES (this));
           if (! NULL_INTERVAL_P (STRING_INTERVALS (this)))
             {
               textprops[num_textprops].argnum = argnum;
@@ -953,7 +952,7 @@ string_to_multibyte (Lisp_Object string)
     return make_multibyte_string (SDATA (string), nbytes, nbytes);
 
   SAFE_ALLOCA (buf, unsigned char *, nbytes);
-  bcopy (SDATA (string), buf, SBYTES (string));
+  memcpy (buf, SDATA (string), SBYTES (string));
   str_to_multibyte (buf, nbytes, SBYTES (string));
 
   ret = make_multibyte_string (buf, SCHARS (string), nbytes);
@@ -1039,7 +1038,7 @@ If STRING is multibyte and contains a character of charset
       int bytes = SBYTES (string);
       unsigned char *str = (unsigned char *) xmalloc (bytes);
 
-      bcopy (SDATA (string), str, bytes);
+      memcpy (str, SDATA (string), bytes);
       bytes = str_as_unibyte (str, bytes);
       string = make_unibyte_string (str, bytes);
       xfree (str);
@@ -1076,8 +1075,7 @@ If you're not sure, whether to use `string-as-multibyte' or
                               SBYTES (string),
                               &nchars, &nbytes);
       new_string = make_uninit_multibyte_string (nchars, nbytes);
-      bcopy (SDATA (string), SDATA (new_string),
-             SBYTES (string));
+      memcpy (SDATA (new_string), SDATA (string), SBYTES (string));
       if (nbytes != SBYTES (string))
         str_as_multibyte (SDATA (new_string), nbytes,
                           SBYTES (string), NULL);
@@ -2170,8 +2168,8 @@ internal_equal (register Lisp_Object o1, register Lisp_Object o2, int depth, int
 
             if (XBOOL_VECTOR (o1)->size != XBOOL_VECTOR (o2)->size)
               return 0;
-            if (bcmp (XBOOL_VECTOR (o1)->data, XBOOL_VECTOR (o2)->data,
-                      size_in_chars))
+            if (memcmp (XBOOL_VECTOR (o1)->data, XBOOL_VECTOR (o2)->data,
+                        size_in_chars))
               return 0;
             return 1;
           }
@@ -2205,8 +2203,7 @@ internal_equal (register Lisp_Object o1, register Lisp_Object o2, int depth, int
         return 0;
       if (SBYTES (o1) != SBYTES (o2))
         return 0;
-      if (bcmp (SDATA (o1), SDATA (o2),
-                SBYTES (o1)))
+      if (memcmp (SDATA (o1), SDATA (o2), SBYTES (o1)))
         return 0;
       if (props && !compare_string_intervals (o1, o2))
         return 0;
@@ -2304,7 +2301,7 @@ This makes STRING unibyte and may change its length.  */)
   int len;
   CHECK_STRING (string);
   len = SBYTES (string);
-  bzero (SDATA (string), len);
+  memset (SDATA (string), 0, len);
   STRING_SET_CHARS (string, len);
   STRING_SET_UNIBYTE (string);
   return Qnil;
@@ -3709,8 +3706,7 @@ larger_vector (Lisp_Object vec, int new_size, Lisp_Object init)
   xassert (new_size >= old_size);
 
   v = allocate_vector (new_size);
-  bcopy (XVECTOR (vec)->contents, v->contents,
-         old_size * sizeof *v->contents);
+  memcpy (v->contents, XVECTOR (vec)->contents, old_size * sizeof *v->contents);
   for (i = old_size; i < new_size; ++i)
     v->contents[i] = init;
   XSETVECTOR (vec, v);
@@ -3947,7 +3943,7 @@ copy_hash_table (struct Lisp_Hash_Table *h1)
 
   h2 = allocate_hash_table ();
   next = h2->vec_next;
-  bcopy (h1, h2, sizeof *h2);
+  memcpy (h2, h1, sizeof *h2);
   h2->vec_next = next;
   h2->key_and_value = Fcopy_sequence (h1->key_and_value);
   h2->hash = Fcopy_sequence (h1->hash);
@@ -4553,7 +4549,7 @@ usage: (make-hash-table &rest KEYWORD-ARGS)  */)
   /* The vector `used' is used to keep track of arguments that
      have been consumed.  */
   used = (char *) alloca (nargs * sizeof *used);
-  bzero (used, nargs * sizeof *used);
+  memset (used, 0, nargs * sizeof *used);
 
   /* See if there's a `:test TEST' among the arguments.  */
   i = get_key_arg (QCtest, nargs, args, used);
diff --git a/src/fringe.c b/src/fringe.c
index b2cff34ba57..b5be2f72ad7 100644
--- a/src/fringe.c
+++ b/src/fringe.c
@@ -1493,7 +1493,7 @@ If BITMAP already exists, the existing definition is replaced.  */)
   xfb = (struct fringe_bitmap *) xmalloc (sizeof fb
                                           + fb.height * BYTES_PER_BITMAP_ROW);
   fb.bits = b = (unsigned short *) (xfb + 1);
-  bzero (b, fb.height);
+  memset (b, 0, fb.height);
 
   j = 0;
   while (j < fb.height)
diff --git a/src/ftfont.c b/src/ftfont.c
index 83d1e033abb..670e7964a53 100644
--- a/src/ftfont.c
+++ b/src/ftfont.c
@@ -1365,7 +1365,7 @@ ftfont_text_extents (struct font *font, unsigned int *code, int nglyphs, struct
   if (ftfont_info->ft_size != ft_face->size)
     FT_Activate_Size (ftfont_info->ft_size);
   if (metrics)
-    bzero (metrics, sizeof (struct font_metrics));
+    memset (metrics, 0, sizeof (struct font_metrics));
   for (i = 0, first = 1; i < nglyphs; i++)
     {
       if (FT_Load_Glyph (ft_face, code[i], FT_LOAD_DEFAULT) == 0)
diff --git a/src/getloadavg.c b/src/getloadavg.c
index a174fc07a01..779a0ef804c 100644
--- a/src/getloadavg.c
+++ b/src/getloadavg.c
@@ -713,7 +713,7 @@ getloadavg (loadavg, nelem)
       for (i = 0; i < conf.config_maxclass; ++i)
         {
           struct class_stats stats;
-          bzero ((char *) &stats, sizeof stats);
+          memset (&stats, 0, sizeof stats);
 
           desc.sd_type = CPUTYPE_CLASS;
           desc.sd_objid = i;
diff --git a/src/image.c b/src/image.c
index be40d1c7b4b..8d618b157b9 100644
--- a/src/image.c
+++ b/src/image.c
@@ -625,7 +625,7 @@ define_image_type (struct image_type *type, int loaded)
       /* Make a copy of TYPE to avoid a bus error in a dumped Emacs.
          The initialized data segment is read-only.  */
       struct image_type *p = (struct image_type *) xmalloc (sizeof *p);
-      bcopy (type, p, sizeof *p);
+      memcpy (p, type, sizeof *p);
       p->next = image_types;
       image_types = p;
       success = Qt;
@@ -1020,7 +1020,7 @@ make_image (Lisp_Object spec, unsigned int hash)
   Lisp_Object file = image_spec_value (spec, QCfile, NULL);
 
   xassert (valid_image_p (spec));
-  bzero (img, sizeof *img);
+  memset (img, 0, sizeof *img);
   img->dependencies = NILP (file) ? Qnil : list1 (file);
   img->type = lookup_image_type (image_spec_value (spec, QCtype, NULL));
   xassert (img->type != NULL);
@@ -1424,12 +1424,12 @@ make_image_cache (void)
   struct image_cache *c = (struct image_cache *) xmalloc (sizeof *c);
   int size;
 
-  bzero (c, sizeof *c);
+  memset (c, 0, sizeof *c);
   c->size = 50;
   c->images = (struct image **) xmalloc (c->size * sizeof *c->images);
   size = IMAGE_CACHE_BUCKETS_SIZE * sizeof *c->buckets;
   c->buckets = (struct image **) xmalloc (size);
-  bzero (c->buckets, size);
+  memset (c->buckets, 0, size);
   return c;
 }
 
@@ -2048,8 +2048,8 @@ x_create_x_image_and_pixmap (struct frame *f, int width, int height, int depth,
       return 0;
     }
 
-  header = &((*ximg)->info.bmiHeader);
-  bzero (&((*ximg)->info), sizeof (BITMAPINFO));
+  header = &(*ximg)->info.bmiHeader;
+  memset (&(*ximg)->info, 0, sizeof (BITMAPINFO));
   header->biSize = sizeof (*header);
   header->biWidth = width;
   header->biHeight = -height;  /* negative indicates a top-down bitmap.  */
@@ -2353,7 +2353,7 @@ xbm_image_p (Lisp_Object object)
 {
   struct image_keyword kw[XBM_LAST];
 
-  bcopy (xbm_format, kw, sizeof kw);
+  memcpy (kw, xbm_format, sizeof kw);
   if (!parse_image_spec (object, kw, XBM_LAST, Qxbm))
     return 0;
 
@@ -2543,7 +2543,7 @@ w32_create_pixmap_from_bitmap_data (int width, int height, char *data)
   w1 = (width + 7) / 8;         /* nb of 8bits elt in X bitmap */
   w2 = ((width + 15) / 16) * 2; /* nb of 16bits elt in W32 bitmap */
   bits = (unsigned char *) alloca (height * w2);
-  bzero (bits, height * w2);
+  memset (bits, 0, height * w2);
   for (i = 0; i < height; i++)
     {
       p = bits + i*w2;
@@ -2918,7 +2918,7 @@ xbm_load (struct frame *f, struct image *img)
       in_memory_file_p = xbm_file_p (data);
 
       /* Parse the image specification.  */
-      bcopy (xbm_format, fmt, sizeof fmt);
+      memcpy (fmt, xbm_format, sizeof fmt);
       parsed_p = parse_image_spec (img->spec, fmt, XBM_LAST, Qxbm);
       xassert (parsed_p);
 
@@ -2964,9 +2964,9 @@ xbm_load (struct frame *f, struct image *img)
                 {
                   Lisp_Object line = XVECTOR (data)->contents[i];
                   if (STRINGP (line))
-                    bcopy (SDATA (line), p, nbytes);
+                    memcpy (p, SDATA (line), nbytes);
                   else
-                    bcopy (XBOOL_VECTOR (line)->data, p, nbytes);
+                    memcpy (p, XBOOL_VECTOR (line)->data, nbytes);
                 }
             }
           else if (STRINGP (data))
@@ -3248,7 +3248,7 @@ xpm_lookup_color (struct frame *f, char *color_name, XColor *color)
      with transparency, and it's useful.  */
   else if (strcmp ("opaque", color_name) == 0)
     {
-      bzero (color, sizeof (XColor));  /* Is this necessary/correct?  */
+      memset (color, 0, sizeof (XColor));  /* Is this necessary/correct?  */
       color->pixel = FRAME_FOREGROUND_PIXEL (f);
       p = xpm_cache_color (f, color_name, color, h);
     }
@@ -3337,7 +3337,7 @@ static int
 xpm_image_p (Lisp_Object object)
 {
   struct image_keyword fmt[XPM_LAST];
-  bcopy (xpm_format, fmt, sizeof fmt);
+  memcpy (fmt, xpm_format, sizeof fmt);
   return (parse_image_spec (object, fmt, XPM_LAST, Qxpm)
           /* Either `:file' or `:data' must be present.  */
           && fmt[XPM_FILE].count + fmt[XPM_DATA].count == 1
@@ -3358,7 +3358,7 @@ x_create_bitmap_from_xpm_data (struct frame *f, char **bits)
   XpmAttributes attrs;
   Pixmap bitmap, mask;
 
-  bzero (&attrs, sizeof attrs);
+  memset (&attrs, 0, sizeof attrs);
 
   attrs.visual = FRAME_X_VISUAL (f);
   attrs.colormap = FRAME_X_COLORMAP (f);
@@ -3406,7 +3406,7 @@ xpm_load (struct frame *f, struct image *img)
 
   /* Configure the XPM lib.  Use the visual of frame F.  Allocate
      close colors.  Return colors allocated.  */
-  bzero (&attrs, sizeof attrs);
+  memset (&attrs, 0, sizeof attrs);
 
 #ifndef HAVE_NTGUI
   attrs.visual = FRAME_X_VISUAL (f);
@@ -3453,7 +3453,7 @@ xpm_load (struct frame *f, struct image *img)
       /* Allocate an XpmColorSymbol array.  */
       size = attrs.numsymbols * sizeof *xpm_syms;
       xpm_syms = (XpmColorSymbol *) alloca (size);
-      bzero (xpm_syms, size);
+      memset (xpm_syms, 0, size);
       attrs.colorsymbols = xpm_syms;
 
       /* Fill the color symbol array.  */
@@ -4152,7 +4152,7 @@ init_color_table (void)
 {
   int size = CT_SIZE * sizeof (*ct_table);
   ct_table = (struct ct_color **) xmalloc (size);
-  bzero (ct_table, size);
+  memset (ct_table, 0, size);
   ct_colors_allocated = 0;
 }
 
@@ -4848,7 +4848,7 @@ x_build_heuristic_mask (struct frame *f, struct image *img, Lisp_Object how)
   /* Create the bit array serving as mask.  */
   row_width = (img->width + 7) / 8;
   mask_img = xmalloc (row_width * img->height);
-  bzero (mask_img, row_width * img->height);
+  memset (mask_img, 0, row_width * img->height);
 
   /* Create a memory device context for IMG->pixmap.  */
   frame_dc = get_frame_dc (f);
@@ -5000,7 +5000,7 @@ pbm_image_p (Lisp_Object object)
 {
   struct image_keyword fmt[PBM_LAST];
 
-  bcopy (pbm_format, fmt, sizeof fmt);
+  memcpy (fmt, pbm_format, sizeof fmt);
 
   if (!parse_image_spec (object, fmt, PBM_LAST, Qpbm))
     return 0;
@@ -5212,7 +5212,7 @@ pbm_load (struct frame *f, struct image *img)
       unsigned long bg = FRAME_BACKGROUND_PIXEL (f);
 
       /* Parse the image specification.  */
-      bcopy (pbm_format, fmt, sizeof fmt);
+      memcpy (fmt, pbm_format, sizeof fmt);
       parse_image_spec (img->spec, fmt, PBM_LAST, Qpbm);
 
       /* Get foreground and background colors, maybe allocate colors.  */
@@ -5415,7 +5415,7 @@ static int
 png_image_p (Lisp_Object object)
 {
   struct image_keyword fmt[PNG_LAST];
-  bcopy (png_format, fmt, sizeof fmt);
+  memcpy (fmt, png_format, sizeof fmt);
 
   if (!parse_image_spec (object, fmt, PNG_LAST, Qpng))
     return 0;
@@ -5554,7 +5554,7 @@ png_read_from_memory (png_structp png_ptr, png_bytep data, png_size_t length)
   if (length > tbr->len - tbr->index)
     fn_png_error (png_ptr, "Read error");
 
-  bcopy (tbr->bytes + tbr->index, data, length);
+  memcpy (data, tbr->bytes + tbr->index, length);
   tbr->index = tbr->index + length;
 }
 
@@ -5756,7 +5756,7 @@ png_load (struct frame *f, struct image *img)
             {
               png_color_16 user_bg;
 
-              bzero (&user_bg, sizeof user_bg);
+              memset (&user_bg, 0, sizeof user_bg);
               user_bg.red = color.red >> shift;
               user_bg.green = color.green >> shift;
               user_bg.blue = color.blue >> shift;
@@ -5776,7 +5776,7 @@ png_load (struct frame *f, struct image *img)
           color.pixel = FRAME_BACKGROUND_PIXEL (f);
           x_query_color (f, &color);
 
-          bzero (&frame_background, sizeof frame_background);
+          memset (&frame_background, 0, sizeof frame_background);
           frame_background.red = color.red >> shift;
           frame_background.green = color.green >> shift;
           frame_background.blue = color.blue >> shift;
@@ -6005,7 +6005,7 @@ jpeg_image_p (Lisp_Object object)
 {
   struct image_keyword fmt[JPEG_LAST];
 
-  bcopy (jpeg_format, fmt, sizeof fmt);
+  memcpy (fmt, jpeg_format, sizeof fmt);
 
   if (!parse_image_spec (object, fmt, JPEG_LAST, Qjpeg))
     return 0;
@@ -6561,7 +6561,7 @@ static int
 tiff_image_p (Lisp_Object object)
 {
   struct image_keyword fmt[TIFF_LAST];
-  bcopy (tiff_format, fmt, sizeof fmt);
+  memcpy (fmt, tiff_format, sizeof fmt);
 
   if (!parse_image_spec (object, fmt, TIFF_LAST, Qtiff))
     return 0;
@@ -6644,7 +6644,7 @@ tiff_read_from_memory (thandle_t data, tdata_t buf, tsize_t size)
 
   if (size > src->len - src->index)
     return (size_t) -1;
-  bcopy (src->bytes + src->index, buf, size);
+  memcpy (buf, src->bytes + src->index, size);
   src->index += size;
   return size;
 }
@@ -6999,7 +6999,7 @@ static int
 gif_image_p (Lisp_Object object)
 {
   struct image_keyword fmt[GIF_LAST];
-  bcopy (gif_format, fmt, sizeof fmt);
+  memcpy (fmt, gif_format, sizeof fmt);
 
   if (!parse_image_spec (object, fmt, GIF_LAST, Qgif))
     return 0;
@@ -7086,7 +7086,7 @@ gif_read_from_memory (GifFileType *file, GifByteType *buf, int len)
   if (len > src->len - src->index)
     return -1;
 
-  bcopy (src->bytes + src->index, buf, len);
+  memcpy (buf, src->bytes + src->index, len);
   src->index += len;
   return len;
 }
@@ -7222,7 +7222,7 @@ gif_load (struct frame *f, struct image *img)
   if (!gif_color_map)
     gif_color_map = gif->SColorMap;
   init_color_table ();
-  bzero (pixel_colors, sizeof pixel_colors);
+  memset (pixel_colors, 0, sizeof pixel_colors);
 
   if (gif_color_map)
     for (i = 0; i < gif_color_map->ColorCount; ++i)
@@ -7432,7 +7432,7 @@ static int
 svg_image_p (Lisp_Object object)
 {
   struct image_keyword fmt[SVG_LAST];
-  bcopy (svg_format, fmt, sizeof fmt);
+  memcpy (fmt, svg_format, sizeof fmt);
 
   if (!parse_image_spec (object, fmt, SVG_LAST, Qsvg))
     return 0;
@@ -7839,7 +7839,7 @@ gs_image_p (Lisp_Object object)
   Lisp_Object tem;
   int i;
 
-  bcopy (gs_format, fmt, sizeof fmt);
+  memcpy (fmt, gs_format, sizeof fmt);
 
   if (!parse_image_spec (object, fmt, GS_LAST, Qpostscript))
     return 0;
diff --git a/src/indent.c b/src/indent.c
index 66f1f4cac49..2d17ccf5c32 100644
--- a/src/indent.c
+++ b/src/indent.c
@@ -546,7 +546,7 @@ scan_for_column (EMACS_INT *endpos, EMACS_INT *goalcol, EMACS_INT *prevcol)
   w = ! NILP (window) ? XWINDOW (window) : NULL;
 
   if (tab_width <= 0 || tab_width > 1000) tab_width = 8;
-  bzero (&cmp_it, sizeof cmp_it);
+  memset (&cmp_it, 0, sizeof cmp_it);
   cmp_it.id = -1;
   composition_compute_stop_pos (&cmp_it, scan, scan_byte, end, Qnil);
 
@@ -1214,7 +1214,7 @@ compute_motion (EMACS_INT from, EMACS_INT fromvpos, EMACS_INT fromhpos, int did_
   pos_byte = prev_pos_byte = CHAR_TO_BYTE (from);
   contin_hpos = 0;
   prev_tab_offset = tab_offset;
-  bzero (&cmp_it, sizeof cmp_it);
+  memset (&cmp_it, 0, sizeof cmp_it);
   cmp_it.id = -1;
   composition_compute_stop_pos (&cmp_it, pos, pos_byte, to, Qnil);
 
diff --git a/src/insdel.c b/src/insdel.c
index 2024cfc362f..1085d645f5c 100644
--- a/src/insdel.c
+++ b/src/insdel.c
@@ -164,28 +164,9 @@ gap_left (EMACS_INT charpos, EMACS_INT bytepos, int newgap)
       /* Move at most 32000 chars before checking again for a quit.  */
       if (i > 32000)
         i = 32000;
-#ifdef GAP_USE_BCOPY
-      if (i >= 128
-          /* bcopy is safe if the two areas of memory do not overlap
-             or on systems where bcopy is always safe for moving upward.  */
-          && (BCOPY_UPWARD_SAFE
-              || to - from >= 128))
-        {
-          /* If overlap is not safe, avoid it by not moving too many
-             characters at once.  */
-          if (!BCOPY_UPWARD_SAFE && i > to - from)
-            i = to - from;
-          new_s1 -= i;
-          from -= i, to -= i;
-          bcopy (from, to, i);
-        }
-      else
-#endif
-        {
-          new_s1 -= i;
-          while (--i >= 0)
-            *--to = *--from;
-        }
+      new_s1 -= i;
+      from -= i, to -= i;
+      memmove (to, from, i);
     }
 
   /* Adjust markers, and buffer data structure, to put the gap at BYTEPOS.
@@ -238,28 +219,9 @@ gap_right (EMACS_INT charpos, EMACS_INT bytepos)
       /* Move at most 32000 chars before checking again for a quit.  */
       if (i > 32000)
         i = 32000;
-#ifdef GAP_USE_BCOPY
-      if (i >= 128
-          /* bcopy is safe if the two areas of memory do not overlap
-             or on systems where bcopy is always safe for moving downward.  */
-          && (BCOPY_DOWNWARD_SAFE
-              || from - to >= 128))
-        {
-          /* If overlap is not safe, avoid it by not moving too many
-             characters at once.  */
-          if (!BCOPY_DOWNWARD_SAFE && i > from - to)
-            i = from - to;
-          new_s1 += i;
-          bcopy (from, to, i);
-          from += i, to += i;
-        }
-      else
-#endif
-        {
-          new_s1 += i;
-          while (--i >= 0)
-            *to++ = *from++;
-        }
+      new_s1 += i;
+      memmove (to, from, i);
+      from += i, to += i;
     }
 
   adjust_markers_gap_motion (GPT_BYTE + GAP_SIZE, bytepos + GAP_SIZE,
@@ -585,7 +547,7 @@ make_gap_smaller (EMACS_INT nbytes_removed)
   /* Pretend that the last unwanted part of the gap is the entire gap,
      and that the first desired part of the gap is part of the buffer
      text.  */
-  bzero (GPT_ADDR, new_gap_size);
+  memset (GPT_ADDR, 0, new_gap_size);
   GPT += new_gap_size;
   GPT_BYTE += new_gap_size;
   Z += new_gap_size;
@@ -636,7 +598,7 @@ copy_text (const unsigned char *from_addr, unsigned char *to_addr,
 {
   if (from_multibyte == to_multibyte)
     {
-      bcopy (from_addr, to_addr, nbytes);
+      memcpy (to_addr, from_addr, nbytes);
       return nbytes;
     }
   else if (from_multibyte)
@@ -966,7 +928,7 @@ insert_1_both (const unsigned char *string,
   MODIFF++;
   CHARS_MODIFF = MODIFF;
 
-  bcopy (string, GPT_ADDR, nbytes);
+  memcpy (GPT_ADDR, string, nbytes);
 
   GAP_SIZE -= nbytes;
   GPT += nchars;
@@ -1007,7 +969,7 @@ insert_1_both (const unsigned char *string,
    copy them into the buffer.
 
    It does not work to use `insert' for this, because a GC could happen
-   before we bcopy the stuff into the buffer, and relocate the string
+   before we copy the stuff into the buffer, and relocate the string
    without insert noticing.  */
 
 void
@@ -1182,7 +1144,7 @@ insert_from_gap (EMACS_INT nchars, EMACS_INT nbytes)
    into the current buffer.
 
    It does not work to use `insert' for this, because a malloc could happen
-   and relocate BUF's text before the bcopy happens.  */
+   and relocate BUF's text before the copy happens.  */
 
 void
 insert_from_buffer (struct buffer *buf,
@@ -1712,7 +1674,7 @@ replace_range_2 (EMACS_INT from, EMACS_INT from_byte,
     make_gap (insbytes - GAP_SIZE);
 
   /* Copy the replacement text into the buffer.  */
-  bcopy (ins, GPT_ADDR, insbytes);
+  memcpy (GPT_ADDR, ins, insbytes);
 
 #ifdef BYTE_COMBINING_DEBUG
   /* We have copied text into the gap, but we have not marked
diff --git a/src/intervals.c b/src/intervals.c
index 3a7a0bf8c96..86cbe1effcc 100644
--- a/src/intervals.c
+++ b/src/intervals.c
@@ -1558,7 +1558,7 @@ reproduce_tree (INTERVAL source, INTERVAL parent)
 {
   register INTERVAL t = make_interval ();
 
-  bcopy (source, t, INTERVAL_SIZE);
+  memcpy (t, source, INTERVAL_SIZE);
   copy_properties (source, t);
   SET_INTERVAL_PARENT (t, parent);
   if (! NULL_LEFT_CHILD (source))
@@ -1574,7 +1574,7 @@ reproduce_tree_obj (INTERVAL source, Lisp_Object parent)
 {
   register INTERVAL t = make_interval ();
 
-  bcopy (source, t, INTERVAL_SIZE);
+  memcpy (t, source, INTERVAL_SIZE);
   copy_properties (source, t);
   SET_INTERVAL_OBJECT (t, parent);
   if (! NULL_LEFT_CHILD (source))
diff --git a/src/keyboard.c b/src/keyboard.c
index c7d3ee413cd..be2dad36bab 100644
--- a/src/keyboard.c
+++ b/src/keyboard.c
@@ -716,7 +716,7 @@ echo_char (Lisp_Object c)
               ptr = buffer + offset;
             }
 
-          bcopy (text, ptr, len);
+          memcpy (ptr, text, len);
           ptr += len;
         }
 
@@ -3481,13 +3481,13 @@ print_help (Lisp_Object object)
 static void
 save_getcjmp (jmp_buf temp)
 {
-  bcopy (getcjmp, temp, sizeof getcjmp);
+  memcpy (temp, getcjmp, sizeof getcjmp);
 }
 
 static void
 restore_getcjmp (jmp_buf temp)
 {
-  bcopy (temp, getcjmp, sizeof getcjmp);
+  memcpy (getcjmp, temp, sizeof getcjmp);
 }
 
 /* Low level keyboard/mouse input.
@@ -3675,7 +3675,7 @@ kbd_buffer_store_event_hold (register struct input_event *event,
 
           if (hold_quit)
             {
-              bcopy (event, (char *) hold_quit, sizeof (*event));
+              memcpy (hold_quit, event, sizeof (*event));
               return;
             }
 
@@ -6336,8 +6336,8 @@ apply_modifiers_uncached (int modifiers, char *base, int base_len, int base_len_
 
     new_name = make_uninit_multibyte_string (mod_len + base_len,
                                              mod_len + base_len_byte);
-    bcopy (new_mods, SDATA (new_name),         mod_len);
-    bcopy (base,     SDATA (new_name) + mod_len, base_len_byte);
+    memcpy (SDATA (new_name), new_mods, mod_len);
+    memcpy (SDATA (new_name) + mod_len, base, base_len_byte);
 
     return Fintern (new_name, Qnil);
   }
@@ -7448,7 +7448,7 @@ store_user_signal_events (void)
 
         if (nstored == 0)
           {
-            bzero (&buf, sizeof buf);
+            memset (&buf, 0, sizeof buf);
             buf.kind = USER_SIGNAL_EVENT;
             buf.frame_or_window = selected_frame;
           }
@@ -7552,7 +7552,7 @@ menu_bar_items (Lisp_Object old)
         nmaps = 0;
         if (tem = get_local_map (PT, current_buffer, Qkeymap), !NILP (tem))
           maps[nmaps++] = tem;
-        bcopy (tmaps, (void *) (maps + nmaps), nminor * sizeof (maps[0]));
+        memcpy (maps + nmaps, tmaps, nminor * sizeof (maps[0]));
         nmaps += nminor;
         maps[nmaps++] = get_local_map (PT, current_buffer, Qlocal_map);
       }
@@ -7593,9 +7593,9 @@ menu_bar_items (Lisp_Object old)
             tem2 = XVECTOR (menu_bar_items_vector)->contents[i + 2];
             tem3 = XVECTOR (menu_bar_items_vector)->contents[i + 3];
             if (end > i + 4)
-              bcopy (&XVECTOR (menu_bar_items_vector)->contents[i + 4],
-                     &XVECTOR (menu_bar_items_vector)->contents[i],
-                     (end - i - 4) * sizeof (Lisp_Object));
+              memmove (&XVECTOR (menu_bar_items_vector)->contents[i],
+                       &XVECTOR (menu_bar_items_vector)->contents[i + 4],
+                       (end - i - 4) * sizeof (Lisp_Object));
             XVECTOR (menu_bar_items_vector)->contents[end - 4] = tem0;
             XVECTOR (menu_bar_items_vector)->contents[end - 3] = tem1;
             XVECTOR (menu_bar_items_vector)->contents[end - 2] = tem2;
@@ -7640,9 +7640,9 @@ menu_bar_item (Lisp_Object key, Lisp_Object item, Lisp_Object dummy1, void *dumm
         if (EQ (key, XVECTOR (menu_bar_items_vector)->contents[i]))
           {
             if (menu_bar_items_index > i + 4)
-              bcopy (&XVECTOR (menu_bar_items_vector)->contents[i + 4],
-                     &XVECTOR (menu_bar_items_vector)->contents[i],
-                     (menu_bar_items_index - i - 4) * sizeof (Lisp_Object));
+              memmove (&XVECTOR (menu_bar_items_vector)->contents[i],
+                       &XVECTOR (menu_bar_items_vector)->contents[i + 4],
+                       (menu_bar_items_index - i - 4) * sizeof (Lisp_Object));
             menu_bar_items_index -= 4;
           }
     }
@@ -8090,7 +8090,7 @@ tool_bar_items (Lisp_Object reuse, int *nitems)
       nmaps = 0;
       if (tem = get_local_map (PT, current_buffer, Qkeymap), !NILP (tem))
         maps[nmaps++] = tem;
-      bcopy (tmaps, (void *) (maps + nmaps), nminor * sizeof (maps[0]));
+      memcpy (maps + nmaps, tmaps, nminor * sizeof (maps[0]));
       nmaps += nminor;
       maps[nmaps++] = get_local_map (PT, current_buffer, Qlocal_map);
     }
@@ -8140,9 +8140,9 @@ process_tool_bar_item (Lisp_Object key, Lisp_Object def, Lisp_Object data, void
           if (EQ (key, v[TOOL_BAR_ITEM_KEY]))
             {
               if (ntool_bar_items > i + TOOL_BAR_ITEM_NSLOTS)
-                bcopy (v + TOOL_BAR_ITEM_NSLOTS, v,
-                       ((ntool_bar_items - i - TOOL_BAR_ITEM_NSLOTS)
-                        * sizeof (Lisp_Object)));
+                memmove (v, v + TOOL_BAR_ITEM_NSLOTS,
+                         ((ntool_bar_items - i - TOOL_BAR_ITEM_NSLOTS)
+                          * sizeof (Lisp_Object)));
               ntool_bar_items -= TOOL_BAR_ITEM_NSLOTS;
               break;
             }
@@ -8425,7 +8425,7 @@ append_tool_bar_item (void)
      tool_bar_items_vector.  */
   to = XVECTOR (tool_bar_items_vector)->contents + ntool_bar_items;
   from = XVECTOR (tool_bar_item_properties)->contents;
-  bcopy (from, to, TOOL_BAR_ITEM_NSLOTS * sizeof *to);
+  memcpy (to, from, TOOL_BAR_ITEM_NSLOTS * sizeof *to);
   ntool_bar_items += TOOL_BAR_ITEM_NSLOTS;
 }
 
@@ -8718,7 +8718,7 @@ read_char_minibuf_menu_prompt (int commandflag, int nmaps, Lisp_Object *maps)
                           thiswidth = SCHARS (desc);
                           if (thiswidth + i > width)
                             thiswidth = width - i;
-                          bcopy (SDATA (desc), menu + i, thiswidth);
+                          memcpy (menu + i, SDATA (desc), thiswidth);
                           i += thiswidth;
                           strcpy (menu + i, " = ");
                           i += 3;
@@ -8728,7 +8728,7 @@ read_char_minibuf_menu_prompt (int commandflag, int nmaps, Lisp_Object *maps)
                       thiswidth = SCHARS (s);
                       if (thiswidth + i > width)
                         thiswidth = width - i;
-                      bcopy (SDATA (s), menu + i, thiswidth);
+                      memcpy (menu + i, SDATA (s), thiswidth);
                       i += thiswidth;
                       menu[i] = 0;
                     }
@@ -9212,8 +9212,7 @@ read_key_sequence (Lisp_Object *keybuf, int bufsize, Lisp_Object prompt,
       if (!NILP (orig_keymap))
         submaps[nmaps++] = orig_keymap;
 
-      bcopy (maps, (void *) (submaps + nmaps),
-             nminor * sizeof (submaps[0]));
+      memcpy (submaps + nmaps, maps, nminor * sizeof (submaps[0]));
 
       nmaps += nminor;
 
@@ -10147,7 +10146,7 @@ will read just one key sequence.  */)
   specbind (Qinput_method_use_echo_area,
             (NILP (command_loop) ? Qt : Qnil));
 
-  bzero (keybuf, sizeof keybuf);
+  memset (keybuf, 0, sizeof keybuf);
   GCPRO1 (keybuf[0]);
   gcpro1.nvars = (sizeof keybuf/sizeof (keybuf[0]));
 
@@ -10207,7 +10206,7 @@ DEFUN ("read-key-sequence-vector", Fread_key_sequence_vector,
   specbind (Qinput_method_use_echo_area,
             (NILP (command_loop) ? Qt : Qnil));
 
-  bzero (keybuf, sizeof keybuf);
+  memset (keybuf, 0, sizeof keybuf);
   GCPRO1 (keybuf[0]);
   gcpro1.nvars = (sizeof keybuf/sizeof (keybuf[0]));
 
@@ -10597,12 +10596,10 @@ DEFUN ("recent-keys", Frecent_keys, Srecent_keys, 0, 0, 0,
   else
     {
       val = Fvector (NUM_RECENT_KEYS, keys);
-      bcopy (keys + recent_keys_index,
-             XVECTOR (val)->contents,
-             (NUM_RECENT_KEYS - recent_keys_index) * sizeof (Lisp_Object));
-      bcopy (keys,
-             XVECTOR (val)->contents + NUM_RECENT_KEYS - recent_keys_index,
-             recent_keys_index * sizeof (Lisp_Object));
+      memcpy (XVECTOR (val)->contents, keys + recent_keys_index,
+              (NUM_RECENT_KEYS - recent_keys_index) * sizeof (Lisp_Object));
+      memcpy (XVECTOR (val)->contents + NUM_RECENT_KEYS - recent_keys_index,
+              keys, recent_keys_index * sizeof (Lisp_Object));
       return val;
     }
 }
diff --git a/src/keymap.c b/src/keymap.c
index c896e6ceb96..7e8b05f9c60 100644
--- a/src/keymap.c
+++ b/src/keymap.c
@@ -1534,7 +1534,8 @@ current_minor_maps (Lisp_Object **modeptr, Lisp_Object **mapptr)
                   {
                     if (cmm_modes)
                       {
-                        bcopy (cmm_modes, newmodes, cmm_size * sizeof cmm_modes[0]);
+                        memcpy (newmodes, cmm_modes,
+                                cmm_size * sizeof cmm_modes[0]);
                         free (cmm_modes);
                       }
                     cmm_modes = newmodes;
@@ -1545,7 +1546,8 @@ current_minor_maps (Lisp_Object **modeptr, Lisp_Object **mapptr)
                   {
                     if (cmm_maps)
                       {
-                        bcopy (cmm_maps, newmaps, cmm_size * sizeof cmm_maps[0]);
+                        memcpy (newmaps, cmm_maps,
+                                cmm_size * sizeof cmm_maps[0]);
                         free (cmm_maps);
                       }
                     cmm_maps = newmaps;
@@ -3100,12 +3102,12 @@ You type        Translation\n\
           *p++ = '\f';
           *p++ = '\n';
           *p++ = '`';
-          bcopy (SDATA (SYMBOL_NAME (modes[i])), p,
-                 SCHARS (SYMBOL_NAME (modes[i])));
+          memcpy (p, SDATA (SYMBOL_NAME (modes[i])),
+                  SCHARS (SYMBOL_NAME (modes[i])));
           p += SCHARS (SYMBOL_NAME (modes[i]));
           *p++ = '\'';
-          bcopy (" Minor Mode Bindings", p, sizeof (" Minor Mode Bindings") - 1);
-          p += sizeof (" Minor Mode Bindings") - 1;
+          memcpy (p, " Minor Mode Bindings", strlen (" Minor Mode Bindings"));
+          p += strlen (" Minor Mode Bindings");
           *p = 0;
 
           describe_map_tree (maps[i], 1, shadow, prefix,
diff --git a/src/lisp.h b/src/lisp.h
index 3a3cde27897..02c9ed03e13 100644
--- a/src/lisp.h
+++ b/src/lisp.h
@@ -647,7 +647,7 @@ extern size_t pure_size;
     (XSTRING (string)->size = (newsize))
 
 #define STRING_COPYIN(string, index, new, count) \
-    bcopy (new, SDATA (string) + index, count)
+    memcpy (SDATA (string) + index, new, count)
 
 /* Type checking.  */
 
@@ -2628,7 +2628,6 @@ EXFUN (Fredisplay, 1);
 extern Lisp_Object sit_for (Lisp_Object, int, int);
 extern void init_display (void);
 extern void syms_of_display (void);
-extern void safe_bcopy (const char *, char *, int);
 
 /* Defined in xdisp.c */
 extern Lisp_Object Qinhibit_point_motion_hooks;
@@ -3400,6 +3399,18 @@ extern int emacs_open (const char *, int, int);
 extern int emacs_close (int);
 extern int emacs_read (int, char *, unsigned int);
 extern int emacs_write (int, const char *, unsigned int);
+#ifndef HAVE_MEMSET
+extern void *memset P_ ((void *, int, size_t));
+#endif
+#ifndef HAVE_MEMCPY
+extern void *memcpy P_ ((void *, void *, size_t));
+#endif
+#ifndef HAVE_MEMMOVE
+extern void *memmove P_ ((void *, void *, size_t));
+#endif
+#ifndef HAVE_MEMCMP
+extern int memcmp P_ ((void *, void *, size_t));
+#endif
 
 /* Defined in filelock.c */
 EXFUN (Funlock_buffer, 0);
diff --git a/src/lread.c b/src/lread.c
index b35d2be78eb..8df689c4afa 100644
--- a/src/lread.c
+++ b/src/lread.c
@@ -1125,8 +1125,7 @@ Return t if the file exists and loads successfully.  */)
   specbind (Qold_style_backquotes, Qnil);
   record_unwind_protect (load_warn_old_style_backquotes, file);
 
-  if (!bcmp (SDATA (found) + SBYTES (found) - 4,
-             ".elc", 4)
+  if (!memcmp (SDATA (found) + SBYTES (found) - 4, ".elc", 4)
       || (fd >= 0 && (version = safe_to_load_p (fd)) > 0))
     /* Load .elc files directly, but not when they are
        remote and have no handler!  */
@@ -2430,8 +2429,7 @@ read1 (register Lisp_Object readcharfun, int *pch, int first_in_list)
                 invalid_syntax ("#&...", 5);
 
               val = Fmake_bool_vector (length, Qnil);
-              bcopy (SDATA (tmp), XBOOL_VECTOR (val)->data,
-                     size_in_chars);
+              memcpy (XBOOL_VECTOR (val)->data, SDATA (tmp), size_in_chars);
               /* Clear the extraneous bits in the last byte.  */
               if (XINT (length) != size_in_chars * BOOL_VECTOR_BITS_PER_CHAR)
                 XBOOL_VECTOR (val)->data[size_in_chars - 1]
@@ -3786,7 +3784,7 @@ oblookup (Lisp_Object obarray, register const char *ptr, int size, int size_byte
       {
         if (SBYTES (SYMBOL_NAME (tail)) == size_byte
             && SCHARS (SYMBOL_NAME (tail)) == size
-            && !bcmp (SDATA (SYMBOL_NAME (tail)), ptr, size_byte))
+            && !memcmp (SDATA (SYMBOL_NAME (tail)), ptr, size_byte))
           return tail;
         else if (XSYMBOL (tail)->next == 0)
           break;
diff --git a/src/msdos.c b/src/msdos.c
index 7e489bb6c47..897963bb24a 100644
--- a/src/msdos.c
+++ b/src/msdos.c
@@ -35,7 +35,7 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 #include <sys/time.h>
 #include <dos.h>
 #include <errno.h>
-#include <string.h>      /* for bzero and string functions */
+#include <string.h>      /* for memset and string functions */
 #include <sys/stat.h>    /* for _fixpath */
 #include <unistd.h>      /* for chdir, dup, dup2, etc. */
 #include <dir.h>         /* for getdisk */
@@ -2929,12 +2929,10 @@ and then the scan code.  */)
   else
     {
       val = Fvector (NUM_RECENT_DOSKEYS, keys);
-      bcopy (keys + recent_doskeys_index,
-             XVECTOR (val)->contents,
-             (NUM_RECENT_DOSKEYS - recent_doskeys_index) * sizeof (Lisp_Object));
-      bcopy (keys,
-             XVECTOR (val)->contents + NUM_RECENT_DOSKEYS - recent_doskeys_index,
-             recent_doskeys_index * sizeof (Lisp_Object));
+      memcpy (XVECTOR (val)->contents, keys + recent_doskeys_index,
+              (NUM_RECENT_DOSKEYS - recent_doskeys_index) * sizeof (Lisp_Object));
+      memcpy (XVECTOR (val)->contents + NUM_RECENT_DOSKEYS - recent_doskeys_index,
+              keys, recent_doskeys_index * sizeof (Lisp_Object));
       return val;
     }
 }
diff --git a/src/nsfns.m b/src/nsfns.m
index 01ef46a3ca1..7180abd6113 100644
--- a/src/nsfns.m
+++ b/src/nsfns.m
@@ -1159,7 +1159,7 @@ be shared by the new frame.  */)
 
   f->output_method = output_ns;
   f->output_data.ns = (struct ns_output *)xmalloc (sizeof *(f->output_data.ns));
-  bzero (f->output_data.ns, sizeof (*(f->output_data.ns)));
+  memset (f->output_data.ns, 0, sizeof (*(f->output_data.ns)));
 
   FRAME_FONTSET (f) = -1;
 
diff --git a/src/nsfont.m b/src/nsfont.m
index db2399a7fa0..3cc1f7fb076 100644
--- a/src/nsfont.m
+++ b/src/nsfont.m
@@ -776,8 +776,8 @@ nsfont_open (FRAME_PTR f, Lisp_Object font_entity, int pixel_size)
     xmalloc (0x100 * sizeof (struct font_metrics *));
   if (!font_info->glyphs || !font_info->metrics)
     return Qnil;
-  bzero (font_info->glyphs, 0x100 * sizeof (unsigned short *));
-  bzero (font_info->metrics, 0x100 * sizeof (struct font_metrics *));
+  memset (font_info->glyphs, 0, 0x100 * sizeof (unsigned short *));
+  memset (font_info->metrics, 0, 0x100 * sizeof (struct font_metrics *));
 
   BLOCK_INPUT;
 
@@ -816,8 +816,8 @@ nsfont_open (FRAME_PTR f, Lisp_Object font_entity, int pixel_size)
     [font_info->nsfont retain];
 
     /* set up ns_font (defined in nsgui.h) */
-    font_info->name = (char *)xmalloc (strlen (fontName) + 1);
-    bcopy (fontName, font_info->name, strlen (fontName) + 1);
+    font_info->name = (char *)xmalloc (strlen (fontName)+1);
+    strcpy (font_info->name, fontName);
     font_info->bold = [fontMgr traitsOfFont: nsfont] & NSBoldFontMask;
     font_info->ital =
       synthItal || ([fontMgr traitsOfFont: nsfont] & NSItalicFontMask);
@@ -972,7 +972,7 @@ nsfont_text_extents (struct font *font, unsigned int *code, int nglyphs,
   int totalWidth = 0;
   int i;
 
-  bzero (metrics, sizeof (struct font_metrics));
+  memset (metrics, 0, sizeof (struct font_metrics));
 
   for (i =0; i<nglyphs; i++)
     {
@@ -1395,7 +1395,7 @@ ns_glyph_metrics (struct nsfont_info *font_info, unsigned char block)
  sfont = [font_info->nsfont screenFont];
 
   font_info->metrics[block] = xmalloc (0x100 * sizeof (struct font_metrics));
-  bzero (font_info->metrics[block], 0x100 * sizeof (struct font_metrics));
+  memset (font_info->metrics[block], 0, 0x100 * sizeof (struct font_metrics));
   if (!(font_info->metrics[block]))
     abort ();
 
diff --git a/src/nsimage.m b/src/nsimage.m
index 3e6a8c77ed7..6912156eb99 100644
--- a/src/nsimage.m
+++ b/src/nsimage.m
@@ -315,9 +315,9 @@ static EmacsImage *ImageList = nil;
 
   [self addRepresentation: bmRep];
 
-  bzero (planes[0], w*h);
-  bzero (planes[1], w*h);
-  bzero (planes[2], w*h);
+  memset (planes[0], 0, w*h);
+  memset (planes[1], 0, w*h);
+  memset (planes[2], 0, w*h);
   [self setXBMColor: [NSColor blackColor]];
   return self;
 }
@@ -379,7 +379,7 @@ static EmacsImage *ImageList = nil;
 
   [bmRep getBitmapDataPlanes: pixmapData];
   for (i =0; i<4; i++)
-    bzero (pixmapData[i], width*height);
+    memset (pixmapData[i], 0, width*height);
   [self addRepresentation: bmRep];
   return self;
 }
diff --git a/src/nsmenu.m b/src/nsmenu.m
index 9034b051297..5c9ce2a6d27 100644
--- a/src/nsmenu.m
+++ b/src/nsmenu.m
@@ -219,8 +219,8 @@ ns_update_menubar (struct frame *f, int deep_p, EmacsMenu *submenu)
 
       /* Save the frame's previous menu bar contents data */
       if (previous_menu_items_used)
-        bcopy (XVECTOR (f->menu_bar_vector)->contents, previous_items,
-               previous_menu_items_used * sizeof (Lisp_Object));
+        memcpy (previous_items, XVECTOR (f->menu_bar_vector)->contents,
+                previous_menu_items_used * sizeof (Lisp_Object));
 
       /* parse stage 1: extract from lisp */
       save_menu_items ();
diff --git a/src/nsterm.m b/src/nsterm.m
index afafc153f9e..62f1c0bcd57 100644
--- a/src/nsterm.m
+++ b/src/nsterm.m
@@ -2163,11 +2163,11 @@ ns_draw_fringe_bitmap (struct window *w, struct glyph_row *row,
     {
       EmacsImage **newBimgs
         = xmalloc (max_used_fringe_bitmap * sizeof (EmacsImage *));
-      bzero (newBimgs, max_used_fringe_bitmap * sizeof (EmacsImage *));
+      memset (newBimgs, 0, max_used_fringe_bitmap * sizeof (EmacsImage *));
 
       if (nBimgs)
         {
-          bcopy (bimgs, newBimgs, nBimgs * sizeof (EmacsImage *));
+          memcpy (newBimgs, bimgs, nBimgs * sizeof (EmacsImage *));
           xfree (bimgs);
         }
 
@@ -3707,7 +3707,7 @@ ns_term_init (Lisp_Object display_name)
                                              name: nil object: nil]; */
 
   dpyinfo = (struct ns_display_info *)xmalloc (sizeof (struct ns_display_info));
-  bzero (dpyinfo, sizeof (struct ns_display_info));
+  memset (dpyinfo, 0, sizeof (struct ns_display_info));
 
   ns_initialize_display_info (dpyinfo);
   terminal = ns_create_terminal (dpyinfo);
diff --git a/src/print.c b/src/print.c
index ea00a90d37b..ce8bc3b4e78 100644
--- a/src/print.c
+++ b/src/print.c
@@ -289,7 +289,7 @@ int print_output_debug_flag = 1;
 static Lisp_Object
 print_unwind (Lisp_Object saved_text)
 {
-  bcopy (SDATA (saved_text), print_buffer, SCHARS (saved_text));
+  memcpy (print_buffer, SDATA (saved_text), SCHARS (saved_text));
   return Qnil;
 }
 
@@ -316,7 +316,7 @@ printchar (unsigned int ch, Lisp_Object fun)
           if (print_buffer_pos_byte + len >= print_buffer_size)
             print_buffer = (char *) xrealloc (print_buffer,
                                               print_buffer_size *= 2);
-          bcopy (str, print_buffer + print_buffer_pos_byte, len);
+          memcpy (print_buffer + print_buffer_pos_byte, str, len);
           print_buffer_pos += 1;
           print_buffer_pos_byte += len;
         }
@@ -364,7 +364,7 @@ strout (const char *ptr, int size, int size_byte, Lisp_Object printcharfun,
           print_buffer = (char *) xrealloc (print_buffer,
                                             print_buffer_size);
         }
-      bcopy (ptr, print_buffer + print_buffer_pos_byte, size_byte);
+      memcpy (print_buffer + print_buffer_pos_byte, ptr, size_byte);
       print_buffer_pos += size;
       print_buffer_pos_byte += size_byte;
     }
@@ -461,7 +461,7 @@ print_string (Lisp_Object string, Lisp_Object printcharfun)
           if (chars < bytes)
             {
               newstr = make_uninit_multibyte_string (chars, bytes);
-              bcopy (SDATA (string), SDATA (newstr), chars);
+              memcpy (SDATA (newstr), SDATA (string), chars);
               str_to_multibyte (SDATA (newstr), bytes, chars);
               string = newstr;
             }
@@ -480,7 +480,7 @@ print_string (Lisp_Object string, Lisp_Object printcharfun)
           USE_SAFE_ALLOCA;
 
           SAFE_ALLOCA (buffer, char *, nbytes);
-          bcopy (SDATA (string), buffer, nbytes);
+          memcpy (buffer, SDATA (string), nbytes);
 
           strout (buffer, chars, SBYTES (string),
                   printcharfun, STRING_MULTIBYTE (string));
@@ -1032,7 +1032,7 @@ print_error_message (Lisp_Object data, Lisp_Object stream, char *context, Lisp_O
     {
       Lisp_Object cname = SYMBOL_NAME (caller);
       char *name = alloca (SBYTES (cname));
-      bcopy (SDATA (cname), name, SBYTES (cname));
+      memcpy (name, SDATA (cname), SBYTES (cname));
       message_dolog (name, SBYTES (cname), 0, 0);
       message_dolog (": ", 2, 0, 0);
     }
diff --git a/src/process.c b/src/process.c
index c7460d81255..67052cac720 100644
--- a/src/process.c
+++ b/src/process.c
@@ -2440,7 +2440,7 @@ conv_lisp_to_sockaddr (int family, Lisp_Object address, struct sockaddr *sa, int
   register unsigned char *cp = NULL;
   register int i;
 
-  bzero (sa, len);
+  memset (sa, 0, len);
 
   if (VECTORP (address))
     {
@@ -2635,12 +2635,12 @@ set_socket_option (int s, Lisp_Object opt, Lisp_Object val)
         /* This is broken, at least in the Linux 2.4 kernel.
            To unbind, the arg must be a zero integer, not the empty string.
            This should work on all systems.   KFS. 2003-09-23.  */
-        bzero (devname, sizeof devname);
+        memset (devname, 0, sizeof devname);
         if (STRINGP (val))
           {
             char *arg = (char *) SDATA (val);
             int len = min (strlen (arg), IFNAMSIZ);
-            bcopy (arg, devname, len);
+            memcpy (devname, arg, len);
           }
         else if (!NILP (val))
           error ("Bad option value for %s", name);
@@ -3349,7 +3349,7 @@ usage: (make-network-process &rest ARGS)  */)
           host = Qnil;
         }
       CHECK_STRING (service);
-      bzero (&address_un, sizeof address_un);
+      memset (&address_un, 0, sizeof address_un);
       address_un.sun_family = AF_LOCAL;
       strncpy (address_un.sun_path, SDATA (service), sizeof address_un.sun_path);
       ai.ai_addr = (struct sockaddr *) &address_un;
@@ -3433,7 +3433,7 @@ usage: (make-network-process &rest ARGS)  */)
       port = svc_info->s_port;
     }
 
-  bzero (&address_in, sizeof address_in);
+  memset (&address_in, 0, sizeof address_in);
   address_in.sin_family = family;
   address_in.sin_addr.s_addr = INADDR_ANY;
   address_in.sin_port = port;
@@ -3457,8 +3457,8 @@ usage: (make-network-process &rest ARGS)  */)
 
       if (host_info_ptr)
         {
-          bcopy (host_info_ptr->h_addr, (char *) &address_in.sin_addr,
-                 host_info_ptr->h_length);
+          memcpy (&address_in.sin_addr, host_info_ptr->h_addr,
+                  host_info_ptr->h_length);
           family = host_info_ptr->h_addrtype;
           address_in.sin_family = family;
         }
@@ -3470,8 +3470,8 @@ usage: (make-network-process &rest ARGS)  */)
           if (numeric_addr == -1)
             error ("Unknown host \"%s\"", SDATA (host));
 
-          bcopy ((char *)&numeric_addr, (char *) &address_in.sin_addr,
-                 sizeof (address_in.sin_addr));
+          memcpy (&address_in.sin_addr, &numeric_addr,
+                  sizeof (address_in.sin_addr));
         }
 
     }
@@ -3655,7 +3655,7 @@ usage: (make-network-process &rest ARGS)  */)
           if (is_server)
             {
               Lisp_Object remote;
-              bzero (datagram_address[s].sa, lres->ai_addrlen);
+              memset (datagram_address[s].sa, 0, lres->ai_addrlen);
               if (remote = Fplist_get (contact, QCremote), !NILP (remote))
                 {
                   int rfamily, rlen;
@@ -3666,7 +3666,7 @@ usage: (make-network-process &rest ARGS)  */)
                 }
             }
           else
-            bcopy (lres->ai_addr, datagram_address[s].sa, lres->ai_addrlen);
+            memcpy (datagram_address[s].sa, lres->ai_addr, lres->ai_addrlen);
         }
 #endif
       contact = Fplist_put (contact, QCaddress,
@@ -3933,7 +3933,7 @@ format; see the description of ADDRESS in `make-network-process'.  */)
       char namebuf[sizeof (ifq->ifr_name) + 1];
       if (ifq->ifr_addr.sa_family != AF_INET)
         continue;
-      bcopy (ifq->ifr_name, namebuf, sizeof (ifq->ifr_name));
+      memcpy (namebuf, ifq->ifr_name, sizeof (ifq->ifr_name));
       namebuf[sizeof (ifq->ifr_name)] = 0;
       res = Fcons (Fcons (build_string (namebuf),
                           conv_sockaddr_to_lisp (&ifq->ifr_addr,
@@ -4036,7 +4036,7 @@ FLAGS is the current flags of the interface.  */)
 
   CHECK_STRING (ifname);
 
-  bzero (rq.ifr_name, sizeof rq.ifr_name);
+  memset (rq.ifr_name, 0, sizeof rq.ifr_name);
   strncpy (rq.ifr_name, SDATA (ifname), sizeof (rq.ifr_name));
 
   s = socket (AF_INET, SOCK_STREAM, 0);
@@ -5277,7 +5277,7 @@ read_process_output (Lisp_Object proc, register int channel)
   chars = (char *) alloca (carryover + readmax);
   if (carryover)
     /* See the comment above.  */
-    bcopy (SDATA (p->decoding_buf), chars, carryover);
+    memcpy (chars, SDATA (p->decoding_buf), carryover);
 
 #ifdef DATAGRAM_SOCKETS
   /* We have a working select, so proc_buffered_char is always -1.  */
@@ -5421,8 +5421,8 @@ read_process_output (Lisp_Object proc, register int channel)
         {
           if (SCHARS (p->decoding_buf) < coding->carryover_bytes)
             p->decoding_buf = make_uninit_string (coding->carryover_bytes);
-          bcopy (coding->carryover, SDATA (p->decoding_buf),
-                 coding->carryover_bytes);
+          memcpy (SDATA (p->decoding_buf), coding->carryover,
+                  coding->carryover_bytes);
           p->decoding_carryover = coding->carryover_bytes;
         }
       if (SBYTES (text) > 0)
@@ -5513,8 +5513,8 @@ read_process_output (Lisp_Object proc, register int channel)
         {
           if (SCHARS (p->decoding_buf) < coding->carryover_bytes)
             p->decoding_buf = make_uninit_string (coding->carryover_bytes);
-          bcopy (coding->carryover, SDATA (p->decoding_buf),
-                 coding->carryover_bytes);
+          memcpy (SDATA (p->decoding_buf), coding->carryover,
+                  coding->carryover_bytes);
           p->decoding_carryover = coding->carryover_bytes;
         }
       /* Adjust the multibyteness of TEXT to that of the buffer.  */
@@ -6517,11 +6517,11 @@ process has been transmitted to the serial port.  */)
       if (!proc_encode_coding_system[new_outfd])
         proc_encode_coding_system[new_outfd]
           = (struct coding_system *) xmalloc (sizeof (struct coding_system));
-      bcopy (proc_encode_coding_system[old_outfd],
-             proc_encode_coding_system[new_outfd],
-             sizeof (struct coding_system));
-      bzero (proc_encode_coding_system[old_outfd],
-             sizeof (struct coding_system));
+      memcpy (proc_encode_coding_system[new_outfd],
+              proc_encode_coding_system[old_outfd],
+              sizeof (struct coding_system));
+      memset (proc_encode_coding_system[old_outfd], 0,
+              sizeof (struct coding_system));
 
       XPROCESS (proc)->outfd = new_outfd;
     }
@@ -7234,10 +7234,10 @@ init_process (void)
       chan_process[i] = Qnil;
       proc_buffered_char[i] = -1;
     }
-  bzero (proc_decode_coding_system, sizeof proc_decode_coding_system);
-  bzero (proc_encode_coding_system, sizeof proc_encode_coding_system);
+  memset (proc_decode_coding_system, 0, sizeof proc_decode_coding_system);
+  memset (proc_encode_coding_system, 0, sizeof proc_encode_coding_system);
 #ifdef DATAGRAM_SOCKETS
-  bzero (datagram_address, sizeof datagram_address);
+  memset (datagram_address, 0, sizeof datagram_address);
 #endif
 
 #ifdef HAVE_SOCKETS
diff --git a/src/ralloc.c b/src/ralloc.c
index dd68e7c8afc..0a2b156e393 100644
--- a/src/ralloc.c
+++ b/src/ralloc.c
@@ -37,11 +37,6 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 typedef POINTER_TYPE *POINTER;
 typedef size_t SIZE;
 
-/* Declared in dispnew.c, this version doesn't screw up if regions
-   overlap.  */
-
-extern void safe_bcopy (const char *, char *, int);
-
 #ifdef DOUG_LEA_MALLOC
 #define M_TOP_PAD           -2
 extern int mallopt (int, int);
@@ -61,9 +56,6 @@ typedef void *POINTER;
 #include <unistd.h>
 #include <malloc.h>
 
-#define safe_bcopy(x, y, z) memmove (y, x, z)
-#define bzero(x, len) memset (x, 0, len)
-
 #endif  /* not emacs */
 
 
@@ -676,7 +668,7 @@ resize_bloc (bloc_ptr bloc, SIZE size)
             }
           else
             {
-              safe_bcopy (b->data, b->new_data, b->size);
+              memmove (b->new_data, b->data, b->size);
               *b->variable = b->data = b->new_data;
             }
         }
@@ -687,8 +679,8 @@ resize_bloc (bloc_ptr bloc, SIZE size)
         }
       else
         {
-          safe_bcopy (bloc->data, bloc->new_data, old_size);
-          bzero ((char *) bloc->new_data + old_size, size - old_size);
+          memmove (bloc->new_data, bloc->data, old_size);
+          memset (bloc->new_data + old_size, 0, size - old_size);
           *bloc->variable = bloc->data = bloc->new_data;
         }
     }
@@ -703,7 +695,7 @@ resize_bloc (bloc_ptr bloc, SIZE size)
             }
           else
             {
-              safe_bcopy (b->data, b->new_data, b->size);
+              memmove (b->new_data, b->data, b->size);
               *b->variable = b->data = b->new_data;
             }
         }
@@ -856,7 +848,7 @@ r_alloc_sbrk (long int size)
              header.  */
           for (b = last_bloc; b != NIL_BLOC; b = b->prev)
             {
-              safe_bcopy (b->data, b->new_data, b->size);
+              memmove (b->new_data, b->data, b->size);
               *b->variable = b->data = b->new_data;
             }
 
@@ -883,7 +875,7 @@ r_alloc_sbrk (long int size)
             last_heap = first_heap;
         }
 
-      bzero (address, size);
+      memset (address, 0, size);
     }
   else /* size < 0 */
     {
@@ -902,7 +894,7 @@ r_alloc_sbrk (long int size)
 
           for (b = first_bloc; b != NIL_BLOC; b = b->next)
             {
-              safe_bcopy (b->data, b->new_data, b->size);
+              memmove (b->new_data, b->data, b->size);
               *b->variable = b->data = b->new_data;
             }
         }
@@ -1082,7 +1074,7 @@ r_alloc_thaw (void)
     abort ();
 
   /* This frees all unused blocs.  It is not too inefficient, as the resize
-     and bcopy is done only once.  Afterwards, all unreferenced blocs are
+     and memcpy is done only once.  Afterwards, all unreferenced blocs are
      already shrunk to zero size.  */
   if (!r_alloc_freeze_level)
     {
@@ -1292,8 +1284,8 @@ r_alloc_init (void)
      even though it is after the sbrk value.  */
   /* Doubly true, with the additional call that explicitly adds the
      rest of that page to the address space.  */
-  bzero (first_heap->start,
-         (char *) first_heap->end - (char *) first_heap->start);
+  memset (first_heap->start, 0,
+          (char *) first_heap->end - (char *) first_heap->start);
   virtual_break_value = break_value = first_heap->bloc_start = first_heap->end;
 #endif
 
diff --git a/src/regex.c b/src/regex.c
index 10ab857b00a..b563d93fe29 100644
--- a/src/regex.c
+++ b/src/regex.c
@@ -248,37 +248,16 @@ xrealloc (block, size)
 # endif
 # define realloc xrealloc
 
-/* When used in Emacs's lib-src, we need to get bzero and bcopy somehow.
-   If nothing else has been done, use the method below.  */
-# ifdef INHIBIT_STRING_HEADER
-#  if !(defined HAVE_BZERO && defined HAVE_BCOPY)
-#   if !defined bzero && !defined bcopy
-#    undef INHIBIT_STRING_HEADER
-#   endif
+/* This is the normal way of making sure we have memcpy, memcmp and memset.  */
+# if defined HAVE_STRING_H || defined STDC_HEADERS || defined _LIBC
+#  include <string.h>
+# else
+#  include <strings.h>
+#  ifndef memcmp
+#   define memcmp(s1, s2, n)    bcmp (s1, s2, n)
 #  endif
-# endif
-
-/* This is the normal way of making sure we have memcpy, memcmp and bzero.
-   This is used in most programs--a few other programs avoid this
-   by defining INHIBIT_STRING_HEADER.  */
-# ifndef INHIBIT_STRING_HEADER
-#  if defined HAVE_STRING_H || defined STDC_HEADERS || defined _LIBC
-#   include <string.h>
-#   ifndef bzero
-#    ifndef _LIBC
-#     define bzero(s, n)        (memset (s, '\0', n), (s))
-#    else
-#     define bzero(s, n)        __bzero (s, n)
-#    endif
-#   endif
-#  else
-#   include <strings.h>
-#   ifndef memcmp
-#    define memcmp(s1, s2, n)   bcmp (s1, s2, n)
-#   endif
-#   ifndef memcpy
-#    define memcpy(d, s, n)     (bcopy (s, d, n), (d))
-#   endif
+#  ifndef memcpy
+#   define memcpy(d, s, n)      (bcopy (s, d, n), (d))
 #  endif
 # endif
 
@@ -464,7 +443,7 @@ init_syntax_once ()
    if (done)
      return;
 
-   bzero (re_syntax_table, sizeof re_syntax_table);
+   memset (re_syntax_table, 0, sizeof re_syntax_table);
 
    for (c = 0; c < CHAR_SET_SIZE; ++c)
      if (ISALNUM (c))
@@ -2948,7 +2927,7 @@ regex_compile (const re_char *pattern, size_t size, reg_syntax_t syntax, struct
             BUF_PUSH ((1 << BYTEWIDTH) / BYTEWIDTH);
 
             /* Clear the whole map.  */
-            bzero (b, (1 << BYTEWIDTH) / BYTEWIDTH);
+            memset (b, 0, (1 << BYTEWIDTH) / BYTEWIDTH);
 
             /* charset_not matches newline according to a syntax bit.  */
             if ((re_opcode_t) b[-2] == charset_not
@@ -4303,7 +4282,7 @@ re_compile_fastmap (struct re_pattern_buffer *bufp)
 
   assert (fastmap && bufp->buffer);
 
-  bzero (fastmap, 1 << BYTEWIDTH);  /* Assume nothing's valid.  */
+  memset (fastmap, 0, 1 << BYTEWIDTH);  /* Assume nothing's valid.  */
   bufp->fastmap_accurate = 1;       /* It will be when we're done.  */
 
   analysis = analyse_first (bufp->buffer, bufp->buffer + bufp->used,
diff --git a/src/s/ms-w32.h b/src/s/ms-w32.h
index ea32373e02b..df9929f6823 100644
--- a/src/s/ms-w32.h
+++ b/src/s/ms-w32.h
@@ -63,15 +63,6 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
    for received packets, so datagrams are broken too.  */
 #define BROKEN_DATAGRAM_SOCKETS 1
 
-#define bzero(b, l) memset(b, 0, l)
-#define bcopy(s, d, l) memmove(d, s, l)
-#define bcmp(a, b, l) memcmp(a, b, l)
-
-/* bcopy (aka memmove aka memcpy at least on x86) under MSVC is quite safe.  */
-#define GAP_USE_BCOPY 1
-#define BCOPY_UPWARD_SAFE 1
-#define BCOPY_DOWNWARD_SAFE 1
-
 /* If your system uses COFF (Common Object File Format) then define the
    preprocessor symbol "COFF".  */
 #define COFF 1
@@ -153,8 +144,10 @@ struct sigaction {
 #define HAVE_RANDOM 1
 #undef  HAVE_SYSINFO
 #undef  HAVE_LRAND48
-#define HAVE_BCOPY 1
-#define HAVE_BCMP 1
+#define HAVE_MEMCMP 1
+#define HAVE_MEMCPY 1
+#define HAVE_MEMMOVE 1
+#define HAVE_MEMSET 1
 #define HAVE_LOGB 1
 #define HAVE_FREXP 1
 #define HAVE_FMOD 1
diff --git a/src/s/msdos.h b/src/s/msdos.h
index af272635968..cffa13cef41 100644
--- a/src/s/msdos.h
+++ b/src/s/msdos.h
@@ -104,10 +104,6 @@ You lose; /* Emacs for DOS must be compiled with DJGPP */
 #define IS_DIRECTORY_SEP(_c_) ((_c_) == '/' || (_c_) == '\\')
 #define IS_ANY_SEP(_c_) (IS_DIRECTORY_SEP (_c_) || IS_DEVICE_SEP (_c_))
 
-/* bcopy under djgpp is quite safe.  */
-#define GAP_USE_BCOPY
-#define BCOPY_UPWARD_SAFE 1
-#define BCOPY_DOWNWARD_SAFE 1
 
 /* Mode line description of a buffer's type.  */
 #define MODE_LINE_BINARY_TEXT(buf) (NILP(buf->buffer_file_type) ? "T" : "B")
diff --git a/src/scroll.c b/src/scroll.c
index f05b59e3bfd..3b033f3bfda 100644
--- a/src/scroll.c
+++ b/src/scroll.c
@@ -258,7 +258,7 @@ do_scrolling (struct frame *frame, struct glyph_matrix *current_matrix, struct m
   int *copy_from = (int *) alloca (window_size * sizeof (int));
 
   /* Zero means line is empty.  */
-  bzero (retained_p, window_size * sizeof (char));
+  memset (retained_p, 0, window_size * sizeof (char));
   for (k = 0; k < window_size; ++k)
     copy_from[k] = -1;
 
@@ -677,7 +677,7 @@ do_direct_scrolling (frame, current_matrix, cost_matrix,
      old matrix.  Lines not retained are empty.  */
   char *retained_p = (char *) alloca (window_size * sizeof (char));
 
-  bzero (retained_p, window_size * sizeof (char));
+  memset (retained_p, 0, window_size * sizeof (char));
 
   /* Perform some sanity checks when GLYPH_DEBUG is on.  */
   CHECK_MATRIX (current_matrix);
@@ -855,7 +855,7 @@ scrolling_max_lines_saved (int start, int end, int *oldhash, int *newhash, int *
   avg_length /= end - start;
   threshold = avg_length / 4;
 
-  bzero (lines, sizeof lines);
+  memset (lines, 0, sizeof lines);
 
   /* Put new lines' hash codes in hash table.  Ignore lines shorter
      than the threshold.  Thus, if the lines that are in common are
diff --git a/src/search.c b/src/search.c
index 004e65e7715..a57136fc3fa 100644
--- a/src/search.c
+++ b/src/search.c
@@ -1404,7 +1404,7 @@ search_buffer (string, pos, pos_byte, lim, lim_byte, n,
                 }
 
               /* Store this character into the translated pattern.  */
-              bcopy (str, pat, charlen);
+              memcpy (pat, str, charlen);
               pat += charlen;
               base_pat += in_charlen;
               len_byte -= in_charlen;
@@ -2178,8 +2178,7 @@ wordify (Lisp_Object string, int lax)
 
       if (SYNTAX (c) == Sword)
         {
-          bcopy (SDATA (string) + i_byte_orig, o,
-                 i_byte - i_byte_orig);
+          memcpy (o, SDATA (string) + i_byte_orig, i_byte - i_byte_orig);
           o += i_byte - i_byte_orig;
         }
       else if (i > 0 && SYNTAX (prev_c) == Sword && --word_count)
@@ -2774,7 +2773,7 @@ since only regular expressions have distinguished subexpressions.  */)
           /* Now add to the end of SUBSTED.  */
           if (add_stuff)
             {
-              bcopy (add_stuff, substed + substed_len, add_len);
+              memcpy (substed + substed_len, add_stuff, add_len);
               substed_len += add_len;
             }
         }
diff --git a/src/sound.c b/src/sound.c
index 6fa6f548917..87703dca5af 100644
--- a/src/sound.c
+++ b/src/sound.c
@@ -550,7 +550,7 @@ wav_init (struct sound *s)
   struct wav_header *header = (struct wav_header *) s->header;
 
   if (s->header_size < sizeof *header
-      || bcmp (s->header, "RIFF", 4) != 0)
+      || memcmp (s->header, "RIFF", 4) != 0)
     return 0;
 
   /* WAV files are in little-endian order.  Convert the header
@@ -658,7 +658,7 @@ au_init (struct sound *s)
   struct au_header *header = (struct au_header *) s->header;
 
   if (s->header_size < sizeof *header
-      || bcmp (s->header, ".snd", 4) != 0)
+      || memcmp (s->header, ".snd", 4) != 0)
     return 0;
 
   header->magic_number = be2hl (header->magic_number);
@@ -1380,9 +1380,9 @@ Internal use only, use `play-sound' instead.  */)
   file = Qnil;
   GCPRO2 (sound, file);
   current_sound_device = (struct sound_device *) xmalloc (sizeof (struct sound_device));
-  bzero (current_sound_device, sizeof (struct sound_device));
+  memset (current_sound_device, 0, sizeof (struct sound_device));
   current_sound = (struct sound *) xmalloc (sizeof (struct sound));
-  bzero (current_sound, sizeof (struct sound));
+  memset (current_sound, 0, sizeof (struct sound));
   record_unwind_protect (sound_cleanup, Qnil);
   current_sound->header = (char *) alloca (MAX_SOUND_HEADER_BYTES);
 
@@ -1405,7 +1405,8 @@ Internal use only, use `play-sound' instead.  */)
     {
       current_sound->data = attrs[SOUND_DATA];
       current_sound->header_size = min (MAX_SOUND_HEADER_BYTES, SBYTES (current_sound->data));
-      bcopy (SDATA (current_sound->data), current_sound->header, current_sound->header_size);
+      memcpy (current_sound->header, SDATA (current_sound->data),
+              current_sound->header_size);
     }
 
   /* Find out the type of sound.  Give up if we can't tell.  */
diff --git a/src/syntax.c b/src/syntax.c
index 2f83b0cc644..7f3557f8441 100644
--- a/src/syntax.c
+++ b/src/syntax.c
@@ -1422,7 +1422,7 @@ skip_chars (int forwardp, Lisp_Object string, Lisp_Object lim, int handle_iso_cl
                && (XINT (lim) - PT != CHAR_TO_BYTE (XINT (lim)) - PT_BYTE));
   string_multibyte = SBYTES (string) > SCHARS (string);
 
-  bzero (fastmap, sizeof fastmap);
+  memset (fastmap, 0, sizeof fastmap);
 
   str = SDATA (string);
   size_byte = SBYTES (string);
@@ -1471,7 +1471,7 @@ skip_chars (int forwardp, Lisp_Object string, Lisp_Object lim, int handle_iso_cl
                   || *class_end != ':' || class_end[1] != ']')
                 goto not_a_class_name;
 
-              bcopy (class_beg, class_name, class_end - class_beg);
+              memcpy (class_name, class_beg, class_end - class_beg);
               class_name[class_end - class_beg] = 0;
 
               cc = re_wctype (class_name);
@@ -1532,8 +1532,8 @@ skip_chars (int forwardp, Lisp_Object string, Lisp_Object lim, int handle_iso_cl
           unsigned char fastmap2[0400];
           int range_start_byte, range_start_char;
 
-          bcopy (fastmap2 + 0200, fastmap + 0200, 0200);
-          bzero (fastmap + 0200, 0200);
+          memcpy (fastmap + 0200, fastmap2 + 0200, 0200);
+          memset (fastmap + 0200, 0, 0200);
           /* We are sure that this loop stops.  */
           for (i = 0200; ! fastmap2[i]; i++);
           c = BYTE8_TO_CHAR (i);
@@ -1593,7 +1593,7 @@ skip_chars (int forwardp, Lisp_Object string, Lisp_Object lim, int handle_iso_cl
                   || *class_end != ':' || class_end[1] != ']')
                 goto not_a_class_name_multibyte;
 
-              bcopy (class_beg, class_name, class_end - class_beg);
+              memcpy (class_name, class_beg, class_end - class_beg);
               class_name[class_end - class_beg] = 0;
 
               cc = re_wctype (class_name);
@@ -1678,7 +1678,7 @@ skip_chars (int forwardp, Lisp_Object string, Lisp_Object lim, int handle_iso_cl
 
       if (! multibyte && n_char_ranges > 0)
         {
-          bzero (fastmap + 0200, 0200);
+          memset (fastmap + 0200, 0, 0200);
           for (i = 0; i < n_char_ranges; i += 2)
             {
               int c1 = char_ranges[i];
@@ -1907,7 +1907,7 @@ skip_syntaxes (int forwardp, Lisp_Object string, Lisp_Object lim)
   multibyte = (!NILP (current_buffer->enable_multibyte_characters)
                && (XINT (lim) - PT != CHAR_TO_BYTE (XINT (lim)) - PT_BYTE));
 
-  bzero (fastmap, sizeof fastmap);
+  memset (fastmap, 0, sizeof fastmap);
 
   if (SBYTES (string) > SCHARS (string))
     /* As this is very rare case (syntax spec is ASCII only), don't
diff --git a/src/sysdep.c b/src/sysdep.c
index d32ba6d4de8..cfa0efa7e87 100644
--- a/src/sysdep.c
+++ b/src/sysdep.c
@@ -623,7 +623,7 @@ sys_subshell (void)
   dir = expand_and_dir_to_file (Funhandled_file_name_directory (dir), Qnil);
   str = (unsigned char *) alloca (SCHARS (dir) + 2);
   len = SCHARS (dir);
-  bcopy (SDATA (dir), str, len);
+  memcpy (str, SDATA (dir), len);
   if (str[len - 1] != '/') str[len++] = '/';
   str[len] = 0;
  xyzzy:
@@ -855,7 +855,7 @@ emacs_get_tty (int fd, struct emacs_tty *settings)
   /* Retrieve the primary parameters - baud rate, character size, etcetera.  */
 #ifdef HAVE_TCATTR
   /* We have those nifty POSIX tcmumbleattr functions.  */
-  bzero (&settings->main, sizeof (settings->main));
+  memset (&settings->main, 0, sizeof (settings->main));
   if (tcgetattr (fd, &settings->main) < 0)
     return -1;
 
@@ -922,7 +922,7 @@ emacs_set_tty (int fd, struct emacs_tty *settings, int flushp)
       {
         struct termios new;
 
-        bzero (&new, sizeof (new));
+        memset (&new, 0, sizeof (new));
         /* Get the current settings, and see if they're what we asked for.  */
         tcgetattr (fd, &new);
         /* We cannot use memcmp on the whole structure here because under
@@ -2715,6 +2715,59 @@ rmdir (char *dpath)
 #endif /* !HAVE_RMDIR */
 
 
+#ifndef HAVE_MEMSET
+void *
+memset (void *b, int n, size_t length)
+{
+  unsigned char *p = b;
+  while (length-- > 0)
+    *p++ = n;
+  return b;
+}
+#endif /* !HAVE_MEMSET */
+
+#ifndef HAVE_MEMCPY
+void *
+memcpy (void *b1, void *b2, size_t length)
+{
+  unsigned char *p1 = b1, *p2 = b2;
+  while (length-- > 0)
+    *p1++ = *p2++;
+  return b1;
+}
+#endif /* !HAVE_MEMCPY */
+
+#ifndef HAVE_MEMMOVE
+void *
+memmove (void *b1, void *b2, size_t length)
+{
+  unsigned char *p1 = b1, *p2 = b2;
+  if (p1 < p2 || p1 >= p2 + length)
+    while (length-- > 0)
+      *p1++ = *p2++;
+  else
+    {
+      p1 += length;
+      p2 += length;
+      while (length-- > 0)
+        *--p1 = *--p2;
+    }
+  return b1;
+}
+#endif /* !HAVE_MEMCPY */
+
+#ifndef HAVE_MEMCMP
+int
+memcmp (void *b1, void *b2, size_t length)
+{
+  unsigned char *p1 = b1, *p2 = b2;
+  while (length-- > 0)
+    if (*p1++ != *p2++)
+      return p1[-1] < p2[-1] ? -1 : 1;
+  return 0;
+}
+#endif /* !HAVE_MEMCMP */
+
 #ifndef HAVE_STRSIGNAL
 char *
 strsignal (int code)
diff --git a/src/term.c b/src/term.c
index fb64ca5d6b3..ec30796bfff 100644
--- a/src/term.c
+++ b/src/term.c
@@ -720,7 +720,7 @@ encode_terminal_code (struct glyph *src, int src_len, struct coding_system *codi
                                                   encode_terminal_src_size);
                   buf = encode_terminal_src + nbytes;
                 }
-              bcopy (SDATA (string), buf, SBYTES (string));
+              memcpy (buf, SDATA (string), SBYTES (string));
               buf += SBYTES (string);
               nchars += SCHARS (string);
             }
@@ -1225,8 +1225,8 @@ calculate_costs (struct frame *frame)
           = (int *) xmalloc (sizeof (int)
                              + 2 * max_frame_cols * sizeof (int));
 
-      bzero (char_ins_del_vector, (sizeof (int)
-                                   + 2 * max_frame_cols * sizeof (int)));
+      memset (char_ins_del_vector, 0,
+              (sizeof (int) + 2 * max_frame_cols * sizeof (int)));
 
 
       if (f && (!tty->TS_ins_line && !tty->TS_del_line))
@@ -1893,7 +1893,7 @@ produce_special_glyphs (struct it *it, enum display_element_type what)
   temp_it.what = IT_CHARACTER;
   temp_it.len = 1;
   temp_it.object = make_number (0);
-  bzero (&temp_it.current, sizeof temp_it.current);
+  memset (&temp_it.current, 0, sizeof temp_it.current);
 
   if (what == IT_CONTINUATION)
     {
@@ -3229,7 +3229,7 @@ create_tty_output (struct frame *f)
     abort ();
 
   t = xmalloc (sizeof (struct tty_output));
-  bzero (t, sizeof (struct tty_output));
+  memset (t, 0, sizeof (struct tty_output));
 
   t->display_info = FRAME_TERMINAL (f)->display_info.tty;
 
@@ -3436,7 +3436,7 @@ init_tty (char *name, char *terminal_type, int must_succeed)
 #else
   tty = (struct tty_display_info *) xmalloc (sizeof (struct tty_display_info));
 #endif
-  bzero (tty, sizeof (struct tty_display_info));
+  memset (tty, 0, sizeof (struct tty_display_info));
   tty->next = tty_list;
   tty_list = tty;
 
@@ -4028,7 +4028,7 @@ delete_tty (struct terminal *terminal)
   xfree (tty->termcap_strings_buffer);
   xfree (tty->termcap_term_buffer);
 
-  bzero (tty, sizeof (struct tty_display_info));
+  memset (tty, 0, sizeof (struct tty_display_info));
   xfree (tty);
 }
 
diff --git a/src/termcap.c b/src/termcap.c
index 5a6d9483a51..fd8a666d0f2 100644
--- a/src/termcap.c
+++ b/src/termcap.c
@@ -46,11 +46,6 @@ char *malloc ();
 char *realloc ();
 #endif
 
-/* Do this after the include, in case string.h prototypes bcopy.  */
-#if (defined(HAVE_STRING_H) || defined(STDC_HEADERS)) && !defined(bcopy)
-#define bcopy(s, d, n) memcpy ((d), (s), (n))
-#endif
-
 #ifdef HAVE_UNISTD_H
 #include <unistd.h>
 #endif
@@ -315,7 +310,7 @@ tgetst1 (char *ptr, char **area)
 
         cut[last_p_param].len = r - cut[last_p_param].beg;
         for (i = 0, wp = ret; i <= last_p_param; wp += cut[i++].len)
-          bcopy (cut[i].beg, wp, cut[i].len);
+          memcpy (wp, cut[i].beg, cut[i].len);
         r = wp;
       }
   }
@@ -739,7 +734,7 @@ gobble_line (int fd, register struct termcap_buffer *bufp, char *append_end)
       else
         {
           append_end -= bufp->ptr - buf;
-          bcopy (bufp->ptr, buf, bufp->full -= bufp->ptr - buf);
+          memcpy (buf, bufp->ptr, bufp->full -= bufp->ptr - buf);
           bufp->ptr = buf;
         }
       if (!(nread = read (fd, buf + bufp->full, bufp->size - bufp->full)))
diff --git a/src/termhooks.h b/src/termhooks.h
index 9af8a6c4f72..7762dd15efe 100644
--- a/src/termhooks.h
+++ b/src/termhooks.h
@@ -255,7 +255,7 @@ struct input_event
   Lisp_Object arg;
 };
 
-#define EVENT_INIT(event) bzero (&(event), sizeof (struct input_event))
+#define EVENT_INIT(event) memset (&(event), 0, sizeof (struct input_event))
 
 /* Bits in the modifiers member of the input_event structure.
    Note that reorder_modifiers assumes that the bits are in canonical
diff --git a/src/tparam.c b/src/tparam.c
index a35647799cb..c768581aeb5 100644
--- a/src/tparam.c
+++ b/src/tparam.c
@@ -35,11 +35,6 @@ char *malloc ();
 char *realloc ();
 #endif
 
-/* Do this after the include, in case string.h prototypes bcopy.  */
-#if (defined(HAVE_STRING_H) || defined(STDC_HEADERS)) && !defined(bcopy)
-#define bcopy(s, d, n) memcpy ((d), (s), (n))
-#endif
-
 #endif /* not emacs */
 
 #ifndef NULL
@@ -151,7 +146,7 @@ tparam1 (char *string, char *outstring, int len, char *up, char *left, register
             {
               outlen = len + 40;
               new = (char *) xmalloc (outlen);
-              bcopy (outstring, new, offset);
+              memcpy (new, outstring, offset);
             }
           else
             {
diff --git a/src/unexalpha.c b/src/unexalpha.c
index 196742a19aa..ab71f6c004c 100644
--- a/src/unexalpha.c
+++ b/src/unexalpha.c
@@ -260,7 +260,7 @@ unexec (new_name, a_name, data_start, bss_start, entry_address)
 
   Brk = brk;
 
-  bcopy (data_section, &old_data_scnhdr, sizeof (old_data_scnhdr));
+  memcpy (&old_data_scnhdr, data_section, sizeof (old_data_scnhdr));
 
   nhdr.aout.dsize = brk - DATA_START;
   nhdr.aout.bsize = 0;
@@ -328,7 +328,7 @@ unexec (new_name, a_name, data_start, bss_start, entry_address)
 #ifdef _GOT
   if (got_section != NULL)
     {
-      bcopy (got_section, buffer, sizeof (struct scnhdr));
+      memcpy (buffer, got_section, sizeof (struct scnhdr));
 
       got_section->s_vaddr = vaddr;
       got_section->s_paddr = vaddr;
@@ -376,7 +376,7 @@ unexec (new_name, a_name, data_start, bss_start, entry_address)
    * Construct new symbol table header
    */
 
-  bcopy (oldptr + nhdr.fhdr.f_symptr, buffer, cbHDRR);
+  memcpy (buffer, oldptr + nhdr.fhdr.f_symptr, cbHDRR);
 
 #define symhdr ((pHDRR)buffer)
   newsyms = nhdr.aout.tsize + nhdr.aout.dsize;
diff --git a/src/unexec.c b/src/unexec.c
index 1a27db1232d..27a15188837 100644
--- a/src/unexec.c
+++ b/src/unexec.c
@@ -472,7 +472,7 @@ write_segment (new, ptr, end)
   int pagesize = getpagesize ();
   char zeros[1 << 13];
 
-  bzero (zeros, sizeof (zeros));
+  memset (zeros, 0, sizeof (zeros));
 
   for (i = 0; ptr < end;)
     {
diff --git a/src/unexmacosx.c b/src/unexmacosx.c
index 3949e5f6e00..1acc009ba90 100644
--- a/src/unexmacosx.c
+++ b/src/unexmacosx.c
@@ -218,7 +218,7 @@ unexec_write_zero (off_t dest, size_t count)
   char buf[UNEXEC_COPY_BUFSZ];
   ssize_t bytes;
 
-  bzero (buf, UNEXEC_COPY_BUFSZ);
+  memset (buf, 0, UNEXEC_COPY_BUFSZ);
   if (lseek (outfd, dest, SEEK_SET) != dest)
     return 0;
 
diff --git a/src/w32fns.c b/src/w32fns.c
index b5af95cca13..96ecf436c45 100644
--- a/src/w32fns.c
+++ b/src/w32fns.c
@@ -2746,7 +2746,7 @@ w32_wnd_proc (HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
       {
         PAINTSTRUCT paintStruct;
         RECT update_rect;
-        bzero (&update_rect, sizeof (update_rect));
+        memset (&update_rect, 0, sizeof (update_rect));
 
         f = x_window_to_frame (dpyinfo, hwnd);
         if (f == 0)
@@ -4275,7 +4275,7 @@ This function is an internal primitive--use `make-frame' instead.  */)
   f->output_method = output_w32;
   f->output_data.w32 =
     (struct w32_output *) xmalloc (sizeof (struct w32_output));
-  bzero (f->output_data.w32, sizeof (struct w32_output));
+  memset (f->output_data.w32, 0, sizeof (struct w32_output));
   FRAME_FONTSET (f) = -1;
 
   f->icon_name
@@ -5388,7 +5388,7 @@ x_create_tip_frame (struct w32_display_info *dpyinfo,
   f->output_method = output_w32;
   f->output_data.w32 =
     (struct w32_output *) xmalloc (sizeof (struct w32_output));
-  bzero (f->output_data.w32, sizeof (struct w32_output));
+  memset (f->output_data.w32, 0, sizeof (struct w32_output));
 
   FRAME_FONTSET (f)  = -1;
   f->icon_name = Qnil;
@@ -6046,7 +6046,7 @@ If ONLY-DIR-P is non-nil, the user can only select directories.  */)
     specbind (Qinhibit_redisplay, Qt);
     BLOCK_INPUT;
 
-    bzero (&new_file_details, sizeof (new_file_details));
+    memset (&new_file_details, 0, sizeof (new_file_details));
     /* Apparently NT4 crashes if you give it an unexpected size.
        I'm not sure about Windows 9x, so play it safe.  */
     if (w32_major_version > 4 && w32_major_version < 95)
@@ -6157,10 +6157,10 @@ DEFUN ("system-move-file-to-trash", Fsystem_move_file_to_trash,
     /* On Windows, write permission is required to delete/move files.  */
     _chmod (path, 0666);
 
-    bzero (tmp_path, sizeof (tmp_path));
+    memset (tmp_path, 0, sizeof (tmp_path));
     strcpy (tmp_path, path);
 
-    bzero (&file_op, sizeof (file_op));
+    memset (&file_op, 0, sizeof (file_op));
     file_op.hwnd = HWND_DESKTOP;
     file_op.wFunc = FO_DELETE;
     file_op.pFrom = tmp_path;
diff --git a/src/w32font.c b/src/w32font.c
index d4dd3e75a7f..2c76e362ce6 100644
--- a/src/w32font.c
+++ b/src/w32font.c
@@ -225,7 +225,7 @@ w32font_list_family (Lisp_Object frame)
   HDC dc;
   FRAME_PTR f = XFRAME (frame);
 
-  bzero (&font_match_pattern, sizeof (font_match_pattern));
+  memset (&font_match_pattern, 0, sizeof (font_match_pattern));
   font_match_pattern.lfCharSet = DEFAULT_CHARSET;
 
   dc = get_frame_dc (f);
@@ -373,7 +373,7 @@ w32font_text_extents (struct font *font, unsigned *code,
 
   if (metrics)
     {
-      bzero (metrics, sizeof (struct font_metrics));
+      memset (metrics, 0, sizeof (struct font_metrics));
       metrics->ascent = font->ascent;
       metrics->descent = font->descent;
 
@@ -394,9 +394,9 @@ w32font_text_extents (struct font *font, unsigned *code,
                   = xrealloc (w32_font->cached_metrics,
                               (block + 1)
                               * sizeof (struct w32_metric_cache *));
-              bzero (w32_font->cached_metrics + w32_font->n_cache_blocks,
-                     ((block + 1 - w32_font->n_cache_blocks)
-                      * sizeof (struct w32_metric_cache *)));
+              memset (w32_font->cached_metrics + w32_font->n_cache_blocks, 0,
+                      ((block + 1 - w32_font->n_cache_blocks)
+                       * sizeof (struct w32_metric_cache *)));
               w32_font->n_cache_blocks = block + 1;
             }
 
@@ -404,8 +404,8 @@ w32font_text_extents (struct font *font, unsigned *code,
             {
               w32_font->cached_metrics[block]
                 = xmalloc (CACHE_BLOCKSIZE * sizeof (struct w32_metric_cache));
-              bzero (w32_font->cached_metrics[block],
-                     CACHE_BLOCKSIZE * sizeof (struct w32_metric_cache));
+              memset (w32_font->cached_metrics[block], 0,
+                      CACHE_BLOCKSIZE * sizeof (struct w32_metric_cache));
             }
 
           char_metric = w32_font->cached_metrics[block] + pos_in_block;
@@ -706,7 +706,7 @@ w32font_list_internal (Lisp_Object frame, Lisp_Object font_spec, int opentype_on
   match_data.list = Qnil;
   match_data.frame = frame;
 
-  bzero (&match_data.pattern, sizeof (LOGFONT));
+  memset (&match_data.pattern, 0, sizeof (LOGFONT));
   fill_in_logfont (f, &match_data.pattern, font_spec);
 
   /* If the charset is unrecognized, then we won't find a font, so don't
@@ -759,7 +759,7 @@ w32font_match_internal (Lisp_Object frame, Lisp_Object font_spec, int opentype_o
   match_data.frame = frame;
   match_data.list = Qnil;
 
-  bzero (&match_data.pattern, sizeof (LOGFONT));
+  memset (&match_data.pattern, 0, sizeof (LOGFONT));
   fill_in_logfont (f, &match_data.pattern, font_spec);
 
   match_data.opentype_only = opentype_only;
@@ -795,7 +795,7 @@ w32font_open_internal (FRAME_PTR f, Lisp_Object font_entity,
   if (!font)
     return 0;
 
-  bzero (&logfont, sizeof (logfont));
+  memset (&logfont, 0, sizeof (logfont));
   fill_in_logfont (f, &logfont, font_entity);
 
   /* Prefer truetype fonts, to avoid known problems with type1 fonts, and
@@ -824,8 +824,8 @@ w32font_open_internal (FRAME_PTR f, Lisp_Object font_entity,
     {
       metrics = (OUTLINETEXTMETRICW *) alloca (len);
       if (GetOutlineTextMetricsW (dc, len, metrics))
-        bcopy (&metrics->otmTextMetrics, &w32_font->metrics,
-               sizeof (TEXTMETRICW));
+        memcpy (&w32_font->metrics, &metrics->otmTextMetrics,
+                sizeof (TEXTMETRICW));
       else
         metrics = NULL;
     }
@@ -2306,7 +2306,7 @@ compute_metrics (HDC dc, struct w32font_info *w32_font, unsigned int code,
   if (w32_font->glyph_idx)
     options |= GGO_GLYPH_INDEX;
 
-  bzero (&transform, sizeof (transform));
+  memset (&transform, 0, sizeof (transform));
   transform.eM11.value = 1;
   transform.eM22.value = 1;
 
@@ -2340,8 +2340,8 @@ in the font selection dialog. */)
   HANDLE oldobj;
   char buf[100];
 
-  bzero (&cf, sizeof (cf));
-  bzero (&lf, sizeof (lf));
+  memset (&cf, 0, sizeof (cf));
+  memset (&lf, 0, sizeof (lf));
 
   cf.lStructSize = sizeof (cf);
   cf.hwndOwner = FRAME_W32_WINDOW (f);
diff --git a/src/w32menu.c b/src/w32menu.c
index 8def7237ba0..c23751d3225 100644
--- a/src/w32menu.c
+++ b/src/w32menu.c
@@ -450,8 +450,8 @@ set_frame_menubar (FRAME_PTR f, int first_time, int deep_p)
 
       /* Save the frame's previous menu bar contents data.  */
       if (previous_menu_items_used)
-        bcopy (XVECTOR (f->menu_bar_vector)->contents, previous_items,
-               previous_menu_items_used * sizeof (Lisp_Object));
+        memcpy (previous_items, XVECTOR (f->menu_bar_vector)->contents,
+                previous_menu_items_used * sizeof (Lisp_Object));
 
       /* Fill in menu_items with the current menu bar contents.
          This can evaluate Lisp code.  */
@@ -1522,7 +1522,7 @@ add_menu_item (HMENU menu, widget_value *wv, HMENU item)
       if (set_menu_item_info)
         {
           MENUITEMINFO info;
-          bzero (&info, sizeof (info));
+          memset (&info, 0, sizeof (info));
           info.cbSize = sizeof (info);
           info.fMask = MIIM_DATA;
 
@@ -1605,7 +1605,7 @@ w32_menu_display_help (HWND owner, HMENU menu, UINT item, UINT flags)
         {
           MENUITEMINFO info;
 
-          bzero (&info, sizeof (info));
+          memset (&info, 0, sizeof (info));
           info.cbSize = sizeof (info);
           info.fMask = MIIM_DATA;
           get_menu_item_info (menu, item, FALSE, &info);
@@ -1642,7 +1642,7 @@ w32_free_submenu_strings (HMENU menu)
   for (i = 0; i < num; i++)
     {
       MENUITEMINFO info;
-      bzero (&info, sizeof (info));
+      memset (&info, 0, sizeof (info));
       info.cbSize = sizeof (info);
       info.fMask = MIIM_DATA | MIIM_TYPE | MIIM_SUBMENU;
 
diff --git a/src/w32term.c b/src/w32term.c
index 1a953be944b..7ace4b01f95 100644
--- a/src/w32term.c
+++ b/src/w32term.c
@@ -323,7 +323,7 @@ XGCValues *
 XCreateGC (void *ignore, Window window, unsigned long mask, XGCValues *xgcv)
 {
   XGCValues *gc = (XGCValues *) xmalloc (sizeof (XGCValues));
-  bzero (gc, sizeof (XGCValues));
+  memset (gc, 0, sizeof (XGCValues));
 
   XChangeGC (ignore, gc, mask, xgcv);
 
@@ -5826,7 +5826,7 @@ w32_initialize_display_info (Lisp_Object display_name)
 {
   struct w32_display_info *dpyinfo = &one_w32_display_info;
 
-  bzero (dpyinfo, sizeof (*dpyinfo));
+  memset (dpyinfo, 0, sizeof (*dpyinfo));
 
   /* Put it on w32_display_name_list.  */
   w32_display_name_list = Fcons (Fcons (display_name, Qnil),
diff --git a/src/w32uniscribe.c b/src/w32uniscribe.c
index f1e5c886b4d..9edd6353ba3 100644
--- a/src/w32uniscribe.c
+++ b/src/w32uniscribe.c
@@ -97,7 +97,7 @@ uniscribe_list_family (Lisp_Object frame)
   HDC dc;
   FRAME_PTR f = XFRAME (frame);
 
-  bzero (&font_match_pattern, sizeof (font_match_pattern));
+  memset (&font_match_pattern, 0, sizeof (font_match_pattern));
   /* Limit enumerated fonts to outline fonts to save time.  */
   font_match_pattern.lfOutPrecision = OUT_OUTLINE_PRECIS;
 
diff --git a/src/w32xfns.c b/src/w32xfns.c
index f57903dc68c..8fee42dae48 100644
--- a/src/w32xfns.c
+++ b/src/w32xfns.c
@@ -178,7 +178,7 @@ get_next_msg (W32Msg * lpmsg, BOOL bWait)
 
   if (nQueue)
     {
-      bcopy (&(lpHead->w32msg), lpmsg, sizeof (W32Msg));
+      memcpy (lpmsg, &lpHead->w32msg, sizeof (W32Msg));
 
       {
         int_msg * lpCur = lpHead;
@@ -250,7 +250,7 @@ post_msg (W32Msg * lpmsg)
   if (!lpNew)
     return (FALSE);
 
-  bcopy (lpmsg, &(lpNew->w32msg), sizeof (W32Msg));
+  memcpy (&lpNew->w32msg, lpmsg, sizeof (W32Msg));
   lpNew->lpNext = NULL;
 
   enter_crit ();
@@ -280,7 +280,7 @@ prepend_msg (W32Msg *lpmsg)
   if (!lpNew)
     return (FALSE);
 
-  bcopy (lpmsg, &(lpNew->w32msg), sizeof (W32Msg));
+  memcpy (&lpNew->w32msg, lpmsg, sizeof (W32Msg));
 
   enter_crit ();
 
diff --git a/src/window.c b/src/window.c
index 28dfc635682..ef7d14595c1 100644
--- a/src/window.c
+++ b/src/window.c
@@ -243,9 +243,9 @@ make_window (void)
   p->dedicated = Qnil;
   p->window_parameters = Qnil;
   p->pseudo_window_p = 0;
-  bzero (&p->cursor, sizeof (p->cursor));
-  bzero (&p->last_cursor, sizeof (p->last_cursor));
-  bzero (&p->phys_cursor, sizeof (p->phys_cursor));
+  memset (&p->cursor, 0, sizeof (p->cursor));
+  memset (&p->last_cursor, 0, sizeof (p->last_cursor));
+  memset (&p->phys_cursor, 0, sizeof (p->phys_cursor));
   p->desired_matrix = p->current_matrix = 0;
   p->nrows_scale_factor = p->ncols_scale_factor = 1;
   p->phys_cursor_type = -1;
@@ -1557,9 +1557,9 @@ replace_window (Lisp_Object old, Lisp_Object replacement)
   p->total_lines = o->total_lines;
   p->desired_matrix = p->current_matrix = 0;
   p->vscroll = 0;
-  bzero (&p->cursor, sizeof (p->cursor));
-  bzero (&p->last_cursor, sizeof (p->last_cursor));
-  bzero (&p->phys_cursor, sizeof (p->phys_cursor));
+  memset (&p->cursor, 0, sizeof (p->cursor));
+  memset (&p->last_cursor, 0, sizeof (p->last_cursor));
+  memset (&p->phys_cursor, 0, sizeof (p->phys_cursor));
   p->phys_cursor_type = -1;
   p->phys_cursor_width = -1;
   p->must_be_updated_p = 0;
@@ -3481,7 +3481,7 @@ set_window_buffer (Lisp_Object window, Lisp_Object buffer, int run_hooks_p, int
 
   XSETFASTINT (w->window_end_pos, 0);
   XSETFASTINT (w->window_end_vpos, 0);
-  bzero (&w->last_cursor, sizeof w->last_cursor);
+  memset (&w->last_cursor, 0, sizeof w->last_cursor);
   w->window_end_valid = Qnil;
   if (!(keep_margins_p && samebuf))
     { /* If we're not actually changing the buffer, don't reset hscroll and
@@ -3948,7 +3948,7 @@ See Info node `(elisp)Splitting Windows' for more details and examples.  */)
   p->parent = o->parent;
   p->buffer = Qt;
   p->window_end_valid = Qnil;
-  bzero (&p->last_cursor, sizeof p->last_cursor);
+  memset (&p->last_cursor, 0, sizeof p->last_cursor);
 
   /* Duplicate special geometry settings.  */
 
diff --git a/src/xdisp.c b/src/xdisp.c
index 1ae2ce97030..545f597e7bc 100644
--- a/src/xdisp.c
+++ b/src/xdisp.c
@@ -2576,7 +2576,7 @@ init_iterator (struct it *it, struct window *w,
     }
 
   /* Clear IT.  */
-  bzero (it, sizeof *it);
+  memset (it, 0, sizeof *it);
   it->current.overlay_string_index = -1;
   it->current.dpvec_index = -1;
   it->base_face_id = remapped_base_face_id;
@@ -4912,7 +4912,7 @@ load_overlay_strings (struct it *it, int charpos)
           entries =                                                     \
             (struct overlay_entry *) alloca (new_size                   \
                                              * sizeof *entries);        \
-          bcopy (old, entries, size * sizeof *entries);                 \
+          memcpy (entries, old, size * sizeof *entries);                \
           size = new_size;                                              \
         }                                                               \
                                                                         \
@@ -5630,7 +5630,7 @@ reseat_to_string (struct it *it, unsigned char *s, Lisp_Object string,
   it->stop_charpos = -1;
 
   /* Set iterator position and end position.  */
-  bzero (&it->current, sizeof it->current);
+  memset (&it->current, 0, sizeof it->current);
   it->current.overlay_string_index = -1;
   it->current.dpvec_index = -1;
   xassert (charpos >= 0);
@@ -7999,7 +7999,7 @@ add_to_log (char *format, Lisp_Object arg1, Lisp_Object arg2)
 
   len = SBYTES (msg) + 1;
   SAFE_ALLOCA (buffer, char *, len);
-  bcopy (SDATA (msg), buffer, len);
+  memcpy (buffer, SDATA (msg), len);
 
   message_dolog (buffer, len - 1, 1, 0);
   SAFE_FREE ();
@@ -8328,7 +8328,7 @@ message3 (Lisp_Object m, int nbytes, int multibyte)
       USE_SAFE_ALLOCA;
 
       SAFE_ALLOCA (buffer, char *, nbytes);
-      bcopy (SDATA (m), buffer, nbytes);
+      memcpy (buffer, SDATA (m), nbytes);
       message_dolog (buffer, nbytes, 1, multibyte);
       SAFE_FREE ();
     }
@@ -9754,7 +9754,7 @@ x_consider_frame_title (Lisp_Object frame)
          higher level than this.)  */
       if (! STRINGP (f->name)
           || SBYTES (f->name) != len
-          || bcmp (title, SDATA (f->name), len) != 0)
+          || memcmp (title, SDATA (f->name), len) != 0)
         x_implicitly_set_name (f, make_string (title, len), Qnil);
     }
 }
@@ -16763,7 +16763,7 @@ append_space_for_newline (struct it *it, int default_face_p)
           saved_pos = it->position;
 
           it->what = IT_CHARACTER;
-          bzero (&it->position, sizeof it->position);
+          memset (&it->position, 0, sizeof it->position);
           it->object = make_number (0);
           it->c = ' ';
           it->len = 1;
@@ -16883,7 +16883,7 @@ extend_face_to_end_of_line (struct it *it)
                 (((it->ascent + it->descent)
                   * FONT_BASE (font)) / FONT_HEIGHT (font));
               saved_pos = it->position;
-              bzero (&it->position, sizeof it->position);
+              memset (&it->position, 0, sizeof it->position);
               saved_avoid_cursor = it->avoid_cursor_p;
               it->avoid_cursor_p = 1;
               saved_face_id = it->face_id;
@@ -16916,7 +16916,7 @@ extend_face_to_end_of_line (struct it *it)
       saved_pos = it->position;
 
       it->what = IT_CHARACTER;
-      bzero (&it->position, sizeof it->position);
+      memset (&it->position, 0, sizeof it->position);
       it->object = make_number (0);
       it->c = ' ';
       it->len = 1;
@@ -19259,7 +19259,7 @@ decode_mode_spec_coding (Lisp_Object coding_system, register char *buf, int eol_
           eol_str = invalid_eol_type;
           eol_str_len = sizeof (invalid_eol_type) - 1;
         }
-      bcopy (eol_str, buf, eol_str_len);
+      memcpy (buf, eol_str, eol_str_len);
       buf += eol_str_len;
     }
 
@@ -20397,7 +20397,7 @@ init_glyph_string (struct glyph_string *s,
                    XChar2b *char2b, struct window *w, struct glyph_row *row,
                    enum glyph_row_area area, int start, enum draw_glyphs_face hl)
 {
-  bzero (s, sizeof *s);
+  memset (s, 0, sizeof *s);
   s->w = w;
   s->f = XFRAME (w->frame);
 #ifdef HAVE_NTGUI
diff --git a/src/xfaces.c b/src/xfaces.c
index 9a6bbd18f8f..d4d68ebdbc2 100644
--- a/src/xfaces.c
+++ b/src/xfaces.c
@@ -764,7 +764,7 @@ x_create_gc (f, mask, xgcv)
 {
   GC gc = xmalloc (sizeof (*gc));
   if (gc)
-      bcopy (xgcv, gc, sizeof (XGCValues));
+    memcpy (gc, xgcv, sizeof (XGCValues));
   return gc;
 }
 
@@ -2190,8 +2190,8 @@ get_lface_attributes_no_remap (struct frame *f, Lisp_Object face_name, Lisp_Obje
   lface = lface_from_face_name_no_resolve (f, face_name, signal_p);
 
   if (! NILP (lface))
-    bcopy (XVECTOR (lface)->contents, attrs,
-           LFACE_VECTOR_SIZE * sizeof *attrs);
+    memcpy (attrs, XVECTOR (lface)->contents,
+            LFACE_VECTOR_SIZE * sizeof *attrs);
 
   return !NILP (lface);
 }
@@ -2861,8 +2861,8 @@ The value is TO.  */)
       copy = Finternal_make_lisp_face (to, new_frame);
     }
 
-  bcopy (XVECTOR (lface)->contents, XVECTOR (copy)->contents,
-         LFACE_VECTOR_SIZE * sizeof (Lisp_Object));
+  memcpy (XVECTOR (copy)->contents, XVECTOR (lface)->contents,
+          LFACE_VECTOR_SIZE * sizeof (Lisp_Object));
 
   /* Changing a named face means that all realized faces depending on
      that face are invalid.  Since we cannot tell which realized faces
@@ -3890,9 +3890,9 @@ Default face attributes override any local face attributes.  */)
         {
           /* Ensure that the face vector is fully specified by merging
              the previously-cached vector.  */
-          bcopy (oldface->lface, attrs, sizeof attrs);
+          memcpy (attrs, oldface->lface, sizeof attrs);
           merge_face_vectors (f, lvec, attrs, 0);
-          bcopy (attrs, lvec, sizeof attrs);
+          memcpy (lvec, attrs, sizeof attrs);
           newface = realize_face (c, lvec, DEFAULT_FACE_ID);
 
           if ((! UNSPECIFIEDP (gvec[LFACE_FAMILY_INDEX])
@@ -3997,7 +3997,7 @@ face_attr_equal_p (Lisp_Object v1, Lisp_Object v2)
       if (SBYTES (v1) != SBYTES (v2))
         return 0;
 
-      return bcmp (SDATA (v1), SDATA (v2), SBYTES (v1)) == 0;
+      return memcmp (SDATA (v1), SDATA (v2), SBYTES (v1)) == 0;
 
     case_Lisp_Int:
     case Lisp_Symbol:
@@ -4169,9 +4169,9 @@ static struct face *
 make_realized_face (Lisp_Object *attr)
 {
   struct face *face = (struct face *) xmalloc (sizeof *face);
-  bzero (face, sizeof *face);
+  memset (face, 0, sizeof *face);
   face->ascii_face = face;
-  bcopy (attr, face->lface, sizeof face->lface);
+  memcpy (face->lface, attr, sizeof face->lface);
   return face;
 }
 
@@ -4316,10 +4316,10 @@ make_face_cache (struct frame *f)
   int size;
 
   c = (struct face_cache *) xmalloc (sizeof *c);
-  bzero (c, sizeof *c);
+  memset (c, 0, sizeof *c);
   size = FACE_CACHE_BUCKETS_SIZE * sizeof *c->buckets;
   c->buckets = (struct face **) xmalloc (size);
-  bzero (c->buckets, size);
+  memset (c->buckets, 0, size);
   c->size = 50;
   c->faces_by_id = (struct face **) xmalloc (c->size * sizeof *c->faces_by_id);
   c->f = f;
@@ -4383,7 +4383,7 @@ free_realized_faces (struct face_cache *c)
 
       c->used = 0;
       size = FACE_CACHE_BUCKETS_SIZE * sizeof *c->buckets;
-      bzero (c->buckets, size);
+      memset (c->buckets, 0, size);
 
       /* Must do a thorough redisplay the next time.  Mark current
          matrices as invalid because they will reference faces freed
@@ -4680,7 +4680,7 @@ lookup_named_face (struct frame *f, Lisp_Object symbol, int signal_p)
   if (! get_lface_attributes (f, symbol, symbol_attrs, signal_p, 0))
     return -1;
 
-  bcopy (default_face->lface, attrs, sizeof attrs);
+  memcpy (attrs, default_face->lface, sizeof attrs);
   merge_face_vectors (f, symbol_attrs, attrs, 0);
 
   return lookup_face (f, attrs);
@@ -4781,7 +4781,7 @@ smaller_face (struct frame *f, int face_id, int steps)
   steps = eabs (steps);
 
   face = FACE_FROM_ID (f, face_id);
-  bcopy (face->lface, attrs, sizeof attrs);
+  memcpy (attrs, face->lface, sizeof attrs);
   pt = last_pt = XFASTINT (attrs[LFACE_HEIGHT_INDEX]);
   new_face_id = face_id;
   last_height = FONT_HEIGHT (face->font);
@@ -4832,7 +4832,7 @@ face_with_height (struct frame *f, int face_id, int height)
     return face_id;
 
   face = FACE_FROM_ID (f, face_id);
-  bcopy (face->lface, attrs, sizeof attrs);
+  memcpy (attrs, face->lface, sizeof attrs);
   attrs[LFACE_HEIGHT_INDEX] = make_number (height);
   font_clear_prop (attrs, FONT_SIZE_INDEX);
   face_id = lookup_face (f, attrs);
@@ -4862,7 +4862,7 @@ lookup_derived_face (struct frame *f, Lisp_Object symbol, int face_id, int signa
   if (!get_lface_attributes (f, symbol, symbol_attrs, signal_p, 0))
     return -1;
 
-  bcopy (default_face->lface, attrs, sizeof attrs);
+  memcpy (attrs, default_face->lface, sizeof attrs);
   merge_face_vectors (f, symbol_attrs, attrs, 0);
   return lookup_face (f, attrs);
 }
@@ -4953,7 +4953,7 @@ x_supports_face_attributes_p (struct frame *f, Lisp_Object *attrs, struct face *
       Lisp_Object merged_attrs[LFACE_VECTOR_SIZE];
       int i;
 
-      bcopy (def_attrs, merged_attrs, sizeof merged_attrs);
+      memcpy (merged_attrs, def_attrs, sizeof merged_attrs);
 
       merge_face_vectors (f, attrs, merged_attrs, 0);
 
@@ -5274,7 +5274,7 @@ Value is ORDER.  */)
   int indices[DIM (font_sort_order)];
 
   CHECK_LIST (order);
-  bzero (indices, sizeof indices);
+  memset (indices, 0, sizeof indices);
   i = 0;
 
   for (list = order;
@@ -5306,9 +5306,9 @@ Value is ORDER.  */)
     if (indices[i] == 0)
       signal_error ("Invalid font sort order", order);
 
-  if (bcmp (indices, font_sort_order, sizeof indices) != 0)
+  if (memcmp (indices, font_sort_order, sizeof indices) != 0)
     {
-      bcopy (indices, font_sort_order, sizeof font_sort_order);
+      memcpy (font_sort_order, indices, sizeof font_sort_order);
       free_all_realized_faces (Qnil);
     }
 
@@ -5553,7 +5553,7 @@ realize_default_face (struct frame *f)
   /* Realize the face; it must be fully-specified now.  */
   xassert (lface_fully_specified_p (XVECTOR (lface)->contents));
   check_lface (lface);
-  bcopy (XVECTOR (lface)->contents, attrs, sizeof attrs);
+  memcpy (attrs, XVECTOR (lface)->contents, sizeof attrs);
   face = realize_face (c, attrs, DEFAULT_FACE_ID);
 
 #ifdef HAVE_WINDOW_SYSTEM
@@ -6074,7 +6074,7 @@ compute_char_face (struct frame *f, int ch, Lisp_Object prop)
     {
       Lisp_Object attrs[LFACE_VECTOR_SIZE];
       struct face *default_face = FACE_FROM_ID (f, DEFAULT_FACE_ID);
-      bcopy (default_face->lface, attrs, sizeof attrs);
+      memcpy (attrs, default_face->lface, sizeof attrs);
       merge_face_ref (f, prop, attrs, 1, 0);
       face_id = lookup_face (f, attrs);
     }
@@ -6163,7 +6163,7 @@ face_at_buffer_position (w, pos, region_beg, region_end,
     return default_face->id;
 
   /* Begin with attributes from the default face.  */
-  bcopy (default_face->lface, attrs, sizeof attrs);
+  memcpy (attrs, default_face->lface, sizeof attrs);
 
   /* Merge in attributes specified via text properties.  */
   if (!NILP (prop))
@@ -6257,7 +6257,7 @@ face_for_overlay_string (w, pos, region_beg, region_end,
     return DEFAULT_FACE_ID;
 
   /* Begin with attributes from the default face.  */
-  bcopy (default_face->lface, attrs, sizeof attrs);
+  memcpy (attrs, default_face->lface, sizeof attrs);
 
   /* Merge in attributes specified via text properties.  */
   if (!NILP (prop))
@@ -6358,7 +6358,7 @@ face_at_string_position (w, string, pos, bufpos, region_beg,
     return base_face->id;
 
   /* Begin with attributes from the base face.  */
-  bcopy (base_face->lface, attrs, sizeof attrs);
+  memcpy (attrs, base_face->lface, sizeof attrs);
 
   /* Merge in attributes specified via text properties.  */
   if (!NILP (prop))
@@ -6413,7 +6413,7 @@ merge_faces (struct frame *f, Lisp_Object face_name, int face_id, int base_face_
     }
 
   /* Begin with attributes from the base face.  */
-  bcopy (base_face->lface, attrs, sizeof attrs);
+  memcpy (attrs, base_face->lface, sizeof attrs);
 
   if (!NILP (face_name))
     {
diff --git a/src/xfns.c b/src/xfns.c
index bf312705229..d6df2e2f836 100644
--- a/src/xfns.c
+++ b/src/xfns.c
@@ -1925,7 +1925,7 @@ xic_create_fontsetname (char *base_fontname, int motif)
     { /* There is no base font name, use the default.  */
       int len = strlen (base_fontname) + 2;
       fontsetname = xmalloc (len);
-      bzero (fontsetname, len);
+      memset (fontsetname, 0, len);
       strcpy (fontsetname, base_fontname);
     }
   else
@@ -1946,7 +1946,7 @@ xic_create_fontsetname (char *base_fontname, int motif)
              Use the specified font plus the default.  */
           int len = strlen (base_fontname) + strlen (xic_defaut_fontset) + 3;
           fontsetname = xmalloc (len);
-          bzero (fontsetname, len);
+          memset (fontsetname, 0, len);
           strcpy (fontsetname, base_fontname);
           strcat (fontsetname, sep);
           strcat (fontsetname, xic_defaut_fontset);
@@ -1983,7 +1983,7 @@ xic_create_fontsetname (char *base_fontname, int motif)
               int diff = (p2 - p3) - 2;
 
               base = alloca (strlen (base_fontname) + 1);
-              bcopy (base_fontname, base, p3 - base_fontname);
+              memcpy (base, base_fontname, p3 - base_fontname);
               base[p3 - base_fontname] = '*';
               base[(p3 - base_fontname) + 1] = '-';
               strcpy (base + (p3 - base_fontname) + 2, p2);
@@ -1996,33 +1996,33 @@ xic_create_fontsetname (char *base_fontname, int motif)
           /* Build the font spec that matches all charsets.  */
           len = p - base_fontname + strlen (allcs) + 1;
           font_allcs = (char *) alloca (len);
-          bzero (font_allcs, len);
-          bcopy (base_fontname, font_allcs, p - base_fontname);
+          memset (font_allcs, 0, len);
+          memcpy (font_allcs, base_fontname, p - base_fontname);
           strcat (font_allcs, allcs);
 
           /* Build the font spec that matches all families and
              add-styles.  */
           len = p - p1 + strlen (allcs) + strlen (allfamilies) + 1;
           font_allfamilies = (char *) alloca (len);
-          bzero (font_allfamilies, len);
+          memset (font_allfamilies, 0, len);
           strcpy (font_allfamilies, allfamilies);
-          bcopy (p1, font_allfamilies + strlen (allfamilies), p - p1);
+          memcpy (font_allfamilies + strlen (allfamilies), p1, p - p1);
           strcat (font_allfamilies, allcs);
 
           /* Build the font spec that matches all.  */
           len = p - p2 + strlen (allcs) + strlen (all) + strlen (allfamilies) + 1;
           font_all = (char *) alloca (len);
-          bzero (font_all, len);
+          memset (font_all, 0, len);
           strcpy (font_all, allfamilies);
           strcat (font_all, all);
-          bcopy (p2, font_all + strlen (all) + strlen (allfamilies), p - p2);
+          memcpy (font_all + strlen (all) + strlen (allfamilies), p2, p - p2);
           strcat (font_all, allcs);
 
           /* Build the actual font set name.  */
           len = strlen (base_fontname) + strlen (font_allcs)
             + strlen (font_allfamilies) + strlen (font_all) + 5;
           fontsetname = xmalloc (len);
-          bzero (fontsetname, len);
+          memset (fontsetname, 0, len);
           strcpy (fontsetname, base_fontname);
           strcat (fontsetname, sep);
           strcat (fontsetname, font_allcs);
@@ -3194,7 +3194,7 @@ This function is an internal primitive--use `make-frame' instead.  */)
 
   f->output_method = output_x_window;
   f->output_data.x = (struct x_output *) xmalloc (sizeof (struct x_output));
-  bzero (f->output_data.x, sizeof (struct x_output));
+  memset (f->output_data.x, 0, sizeof (struct x_output));
   f->output_data.x->icon_bitmap = -1;
   FRAME_FONTSET (f) = -1;
   f->output_data.x->scroll_bar_foreground_pixel = -1;
@@ -4431,7 +4431,7 @@ no value of TYPE.  */)
              elements."
              This applies even if long is more than 32 bits, the X library
              converts from 32 bit elements received from the X server to long
-             and passes the long array to us.  Thus, for that case bcopy can not
+             and passes the long array to us.  Thus, for that case memcpy can not
              be used.  We convert to a 32 bit type here, because so much code
              assume on that.
 
@@ -4687,7 +4687,7 @@ x_create_tip_frame (struct x_display_info *dpyinfo, Lisp_Object parms, Lisp_Obje
      counts etc.  */
   f->output_method = output_x_window;
   f->output_data.x = (struct x_output *) xmalloc (sizeof (struct x_output));
-  bzero (f->output_data.x, sizeof (struct x_output));
+  memset (f->output_data.x, 0, sizeof (struct x_output));
   f->output_data.x->icon_bitmap = -1;
   FRAME_FONTSET (f) = -1;
   f->output_data.x->scroll_bar_foreground_pixel = -1;
@@ -5729,9 +5729,9 @@ present and mapped to the usual X keysyms.  */)
               /* The XKB symbolic key names can be seen most easily in
                  the PS file generated by `xkbprint -label name
                  $DISPLAY'.  */
-              if (bcmp ("DELE", kb->names->keys[i].name, 4) == 0)
+              if (memcmp ("DELE", kb->names->keys[i].name, 4) == 0)
                 delete_keycode = i;
-              else if (bcmp ("BKSP", kb->names->keys[i].name, 4) == 0)
+              else if (memcmp ("BKSP", kb->names->keys[i].name, 4) == 0)
                 backspace_keycode = i;
             }
 
diff --git a/src/xfont.c b/src/xfont.c
index b1e793de808..b03bb1585d3 100644
--- a/src/xfont.c
+++ b/src/xfont.c
@@ -562,7 +562,7 @@ xfont_list (Lisp_Object frame, Lisp_Object spec)
       val = assq_no_quit (QCname, AREF (spec, FONT_EXTRA_INDEX));
       if (CONSP (val) && STRINGP (XCDR (val)) && SBYTES (XCDR (val)) < 512)
         {
-          bcopy (SDATA (XCDR (val)), name, SBYTES (XCDR (val)) + 1);
+          memcpy (name, SDATA (XCDR (val)), SBYTES (XCDR (val)) + 1);
           if (xfont_encode_coding_xlfd (name) < 0)
             return Qnil;
           list = xfont_list_pattern (display, name, registry, script);
@@ -590,7 +590,7 @@ xfont_match (Lisp_Object frame, Lisp_Object spec)
         return Qnil;
     }
   else if (SBYTES (XCDR (val)) < 512)
-    bcopy (SDATA (XCDR (val)), name, SBYTES (XCDR (val)) + 1);
+    memcpy (name, SDATA (XCDR (val)), SBYTES (XCDR (val)) + 1);
   else
     return Qnil;
   if (xfont_encode_coding_xlfd (name) < 0)
@@ -669,7 +669,7 @@ xfont_list_family (Lisp_Object frame)
       if (! *p1 || p1 == p0)
         continue;
       if (last_len == p1 - p0
-          && bcmp (last_family, p0, last_len) == 0)
+          && memcmp (last_family, p0, last_len) == 0)
         continue;
       last_len = p1 - p0;
       last_family = p0;
@@ -980,7 +980,7 @@ xfont_text_extents (struct font *font, unsigned int *code, int nglyphs, struct f
   int i, first, x;
 
   if (metrics)
-    bzero (metrics, sizeof (struct font_metrics));
+    memset (metrics, 0, sizeof (struct font_metrics));
   for (i = 0, x = 0, first = 1; i < nglyphs; i++)
     {
       XChar2b char2b;
diff --git a/src/xmenu.c b/src/xmenu.c
index deb7c091877..701433e7907 100644
--- a/src/xmenu.c
+++ b/src/xmenu.c
@@ -1067,8 +1067,8 @@ set_frame_menubar (FRAME_PTR f, int first_time, int deep_p)
 
       /* Save the frame's previous menu bar contents data.  */
       if (previous_menu_items_used)
-        bcopy (XVECTOR (f->menu_bar_vector)->contents, previous_items,
-               previous_menu_items_used * sizeof (Lisp_Object));
+        memcpy (previous_items, XVECTOR (f->menu_bar_vector)->contents,
+                previous_menu_items_used * sizeof (Lisp_Object));
 
       /* Fill in menu_items with the current menu bar contents.
          This can evaluate Lisp code.  */
@@ -2452,12 +2452,10 @@ xmenu_show (f, x, y, for_click, keymaps, title, error, timestamp)
               item_data
                 = (unsigned char *) alloca (maxwidth
                                             + SBYTES (descrip) + 1);
-              bcopy (SDATA (item_name), item_data,
-                     SBYTES (item_name));
+              memcpy (item_data, SDATA (item_name), SBYTES (item_name));
               for (j = SCHARS (item_name); j < maxwidth; j++)
                 item_data[j] = ' ';
-              bcopy (SDATA (descrip), item_data + j,
-                     SBYTES (descrip));
+              memcpy (item_data + j, SDATA (descrip), SBYTES (descrip));
               item_data[j + SBYTES (descrip)] = 0;
             }
           else
diff --git a/src/xrdb.c b/src/xrdb.c
index f9033f22e7f..513768e3cde 100644
--- a/src/xrdb.c
+++ b/src/xrdb.c
@@ -233,7 +233,7 @@ magic_file_p (char *string, int string_len, char *class, char *escaped_suffix, c
           path = (char *) realloc (path, path_size);
         }
 
-      bcopy (next, path + path_len, next_len);
+      memcpy (path + path_len, next, next_len);
       path_len += next_len;
 
       p++;
@@ -259,7 +259,7 @@ magic_file_p (char *string, int string_len, char *class, char *escaped_suffix, c
           path = (char *) realloc (path, path_size);
         }
 
-      bcopy (suffix, path + path_len, suffix_len);
+      memcpy (path + path_len, suffix, suffix_len);
       path_len += suffix_len;
     }
 
@@ -644,7 +644,7 @@ x_get_resource (XrmDatabase rdb, char *name, char *class, XrmRepresentation expe
       if (type == x_rm_string)
         ret_value->addr = (char *) value.addr;
       else
-        bcopy (value.addr, ret_value->addr, ret_value->size);
+        memcpy (ret_value->addr, value.addr, ret_value->size);
 
       return value.size;
     }
diff --git a/src/xselect.c b/src/xselect.c
index 6d076235316..df260e3d8f1 100644
--- a/src/xselect.c
+++ b/src/xselect.c
@@ -191,7 +191,7 @@ x_queue_event (struct input_event *event)
      This only happens for large requests which uses the incremental protocol.  */
   for (queue_tmp = selection_queue; queue_tmp; queue_tmp = queue_tmp->next)
     {
-      if (!bcmp (&queue_tmp->event, event, sizeof (*event)))
+      if (!memcmp (&queue_tmp->event, event, sizeof (*event)))
         {
           TRACE1 ("DECLINE DUP SELECTION EVENT %08lx", (unsigned long)queue_tmp);
           x_decline_selection_request (event);
@@ -1534,7 +1534,7 @@ x_get_window_property (display, window, property, data_ret, bytes_ret,
           elements."
          This applies even if long is more than 32 bits, the X library
          converts from 32 bit elements received from the X server to long
-         and passes the long array to us.  Thus, for that case bcopy can not
+         and passes the long array to us.  Thus, for that case memcpy can not
          be used.  We convert to a 32 bit type here, because so much code
          assume on that.
 
@@ -1556,7 +1556,7 @@ x_get_window_property (display, window, property, data_ret, bytes_ret,
       else
         {
           *actual_size_ret *= *actual_format_ret / 8;
-          bcopy (tmp_data, (*data_ret) + offset, *actual_size_ret);
+          memcpy ((*data_ret) + offset, tmp_data, *actual_size_ret);
           offset += *actual_size_ret;
         }
 
@@ -1658,7 +1658,7 @@ receive_incremental_selection (display, window, property, target_type,
           *data_ret = (unsigned char *) xrealloc (*data_ret, *size_bytes_ret);
         }
 
-      bcopy (tmp_data, (*data_ret) + offset, tmp_size_bytes);
+      memcpy ((*data_ret) + offset, tmp_data, tmp_size_bytes);
       offset += tmp_size_bytes;
 
       /* Use xfree, not XFree, because x_get_window_property
diff --git a/src/xsmfns.c b/src/xsmfns.c
index 2ebd4a45c41..29e48e8f22e 100644
--- a/src/xsmfns.c
+++ b/src/xsmfns.c
@@ -154,7 +154,7 @@ x_session_check_input (struct input_event *bufp)
   /* Check if smc_interact_CB was called and we shall generate a
      SAVE_SESSION_EVENT.  */
   if (emacs_event.kind != NO_EVENT)
-    bcopy (&emacs_event, bufp, sizeof (struct input_event));
+    memcpy (bufp, &emacs_event, sizeof (struct input_event));
 
   return emacs_event.kind != NO_EVENT ? 1 : 0;
 }
diff --git a/src/xterm.c b/src/xterm.c
index 49c2ed6299d..d1bf9eaa5ea 100644
--- a/src/xterm.c
+++ b/src/xterm.c
@@ -4131,7 +4131,7 @@ x_send_scroll_bar_event (Lisp_Object window, int part, int portion, int whole)
 
       scroll_bar_windows = (struct window **) xrealloc (scroll_bar_windows,
                                                         nbytes);
-      bzero (&scroll_bar_windows[i], nbytes - old_nbytes);
+      memset (&scroll_bar_windows[i], 0, nbytes - old_nbytes);
       scroll_bar_windows_size = new_size;
     }
 
@@ -5608,7 +5608,7 @@ static struct x_display_info *next_noop_dpyinfo;
          if (f->output_data.x->saved_menu_event == 0)                   \
            f->output_data.x->saved_menu_event                           \
              = (XEvent *) xmalloc (sizeof (XEvent));                    \
-         bcopy (&event, f->output_data.x->saved_menu_event, size);      \
+         memcpy (f->output_data.x->saved_menu_event, &event, size);     \
          inev.ie.kind = MENU_BAR_ACTIVATE_EVENT;                        \
          XSETFRAME (inev.ie.frame_or_window, f);                        \
        }                                                                \
@@ -6245,7 +6245,7 @@ handle_one_xevent (struct x_display_info *dpyinfo, XEvent *eventp, int *finish,
              this enables ComposeCharacter to work whether or
              not it is combined with Meta.  */
           if (modifiers & dpyinfo->meta_mod_mask)
-            bzero (&compose_status, sizeof (compose_status));
+            memset (&compose_status, 0, sizeof (compose_status));
 
 #ifdef HAVE_X_I18N
           if (FRAME_XIC (f))
@@ -6293,7 +6293,7 @@ handle_one_xevent (struct x_display_info *dpyinfo, XEvent *eventp, int *finish,
           if (compose_status.chars_matched > 0 && nbytes == 0)
             break;
 
-          bzero (&compose_status, sizeof (compose_status));
+          memset (&compose_status, 0, sizeof (compose_status));
           orig_keysym = keysym;
 
           /* Common for all keysym input events.  */
@@ -6707,7 +6707,7 @@ handle_one_xevent (struct x_display_info *dpyinfo, XEvent *eventp, int *finish,
            by the rest of Emacs, we put it here.  */
         int tool_bar_p = 0;
 
-        bzero (&compose_status, sizeof (compose_status));
+        memset (&compose_status, 0, sizeof (compose_status));
         last_mouse_glyph_frame = 0;
         last_user_time = event.xbutton.time;
 
@@ -7553,7 +7553,7 @@ x_check_errors (Display *dpy, char *format)
   if (x_error_message->string[0])
     {
       char string[X_ERROR_MESSAGE_SIZE];
-      bcopy (x_error_message->string, string, X_ERROR_MESSAGE_SIZE);
+      memcpy (string, x_error_message->string, X_ERROR_MESSAGE_SIZE);
       x_uncatch_errors ();
       error (format, string);
     }
@@ -8077,7 +8077,7 @@ xim_initialize (struct x_display_info *dpyinfo, char *resource_name)
       xim_inst->dpyinfo = dpyinfo;
       len = strlen (resource_name);
       xim_inst->resource_name = (char *) xmalloc (len + 1);
-      bcopy (resource_name, xim_inst->resource_name, len + 1);
+      memcpy (xim_inst->resource_name, resource_name, len + 1);
       XRegisterIMInstantiateCallback (dpyinfo->display, dpyinfo->xrdb,
                                       resource_name, EMACS_CLASS,
                                       xim_instantiate_callback,
@@ -9929,7 +9929,7 @@ x_term_init (Lisp_Object display_name, char *xrm_option, char *resource_name)
   /* We have definitely succeeded.  Record the new connection.  */
 
   dpyinfo = (struct x_display_info *) xmalloc (sizeof (struct x_display_info));
-  bzero (dpyinfo, sizeof *dpyinfo);
+  memset (dpyinfo, 0, sizeof *dpyinfo);
 
   terminal = x_create_terminal (dpyinfo);