Merge branch 'master' of git.sv.gnu.org:/srv/git/emacs into feature/pgtk

35 files changed, 563 insertions, 515 deletions

diff --git a/src/Makefile.in b/src/Makefile.in
index ce809e90c82..b0d4be0a56c 100644
--- a/src/Makefile.in
+++ b/src/Makefile.in
@@ -341,7 +341,7 @@ HAVE_PDUMPER = @HAVE_PDUMPER@
 
 ## ARM Macs require that all code have a valid signature.  Since pump
 ## invalidates the signature, we must re-sign to fix it.
-DO_CODESIGN=$(patsubst aarch64-apple-darwin%,yes,@configuration@)
+DO_CODESIGN=$(patsubst arm-apple-darwin%,yes,@configuration@)
 
 # 'make' verbosity.
 AM_DEFAULT_VERBOSITY = @AM_DEFAULT_VERBOSITY@
diff --git a/src/alloc.c b/src/alloc.c
index 51088eb0e77..42d096ef2ae 100644
--- a/src/alloc.c
+++ b/src/alloc.c
@@ -664,7 +664,7 @@ display_malloc_warning (void)
   call3 (intern ("display-warning"),
          intern ("alloc"),
          build_string (pending_malloc_warning),
-         intern ("emergency"));
+         intern (":emergency"));
   pending_malloc_warning = 0;
 }
 
@@ -732,7 +732,11 @@ static void
 malloc_unblock_input (void)
 {
   if (block_input_in_memory_allocators)
-    unblock_input ();
+    {
+      int err = errno;
+      unblock_input ();
+      errno = err;
+    }
 }
 # define MALLOC_BLOCK_INPUT malloc_block_input ()
 # define MALLOC_UNBLOCK_INPUT malloc_unblock_input ()
diff --git a/src/buffer.c b/src/buffer.c
index dfc34faf6e6..9e44345616e 100644
--- a/src/buffer.c
+++ b/src/buffer.c
@@ -37,7 +37,6 @@ along with GNU Emacs.  If not, see <https://www.gnu.org/licenses/>.  */
 #include "window.h"
 #include "commands.h"
 #include "character.h"
-#include "coding.h"
 #include "buffer.h"
 #include "region-cache.h"
 #include "indent.h"
@@ -514,16 +513,33 @@ get_truename_buffer (register Lisp_Object filename)
   return Qnil;
 }
 
-DEFUN ("get-buffer-create", Fget_buffer_create, Sget_buffer_create, 1, 1, 0,
+/* Run buffer-list-update-hook if Vrun_hooks is non-nil, and BUF is NULL
+   or does not have buffer hooks inhibited.  BUF is NULL when called by
+   make-indirect-buffer, since it does not inhibit buffer hooks.  */
+
+static void
+run_buffer_list_update_hook (struct buffer *buf)
+{
+  if (! (NILP (Vrun_hooks) || (buf && buf->inhibit_buffer_hooks)))
+    call1 (Vrun_hooks, Qbuffer_list_update_hook);
+}
+
+DEFUN ("get-buffer-create", Fget_buffer_create, Sget_buffer_create, 1, 2, 0,
        doc: /* Return the buffer specified by BUFFER-OR-NAME, creating a new one if needed.
 If BUFFER-OR-NAME is a string and a live buffer with that name exists,
 return that buffer.  If no such buffer exists, create a new buffer with
-that name and return it.  If BUFFER-OR-NAME starts with a space, the new
-buffer does not keep undo information.
+that name and return it.
+
+If BUFFER-OR-NAME starts with a space, the new buffer does not keep undo
+information.  If optional argument INHIBIT-BUFFER-HOOKS is non-nil, the
+new buffer does not run the hooks `kill-buffer-hook',
+`kill-buffer-query-functions', and `buffer-list-update-hook'.  This
+avoids slowing down internal or temporary buffers that are never
+presented to users or passed on to other applications.
 
 If BUFFER-OR-NAME is a buffer instead of a string, return it as given,
 even if it is dead.  The return value is never nil.  */)
-  (register Lisp_Object buffer_or_name)
+  (register Lisp_Object buffer_or_name, Lisp_Object inhibit_buffer_hooks)
 {
   register Lisp_Object buffer, name;
   register struct buffer *b;
@@ -598,11 +614,7 @@ even if it is dead.  The return value is never nil.  */)
   set_string_intervals (name, NULL);
   bset_name (b, name);
 
-  b->inhibit_buffer_hooks
-    = (STRINGP (Vcode_conversion_workbuf_name)
-       && strncmp (SSDATA (name), SSDATA (Vcode_conversion_workbuf_name),
-                   SBYTES (Vcode_conversion_workbuf_name)) == 0);
-
+  b->inhibit_buffer_hooks = !NILP (inhibit_buffer_hooks);
   bset_undo_list (b, SREF (name, 0) != ' ' ? Qnil : Qt);
 
   reset_buffer (b);
@@ -614,9 +626,8 @@ even if it is dead.  The return value is never nil.  */)
   /* Put this in the alist of all live buffers.  */
   XSETBUFFER (buffer, b);
   Vbuffer_alist = nconc2 (Vbuffer_alist, list1 (Fcons (name, buffer)));
-  /* And run buffer-list-update-hook.  */
-  if (!NILP (Vrun_hooks) && !b->inhibit_buffer_hooks)
-    call1 (Vrun_hooks, Qbuffer_list_update_hook);
+
+  run_buffer_list_update_hook (b);
 
   return buffer;
 }
@@ -890,9 +901,7 @@ CLONE nil means the indirect buffer's state is reset to default values.  */)
       set_buffer_internal_1 (old_b);
     }
 
-  /* Run buffer-list-update-hook.  */
-  if (!NILP (Vrun_hooks))
-    call1 (Vrun_hooks, Qbuffer_list_update_hook);
+  run_buffer_list_update_hook (NULL);
 
   return buf;
 }
@@ -1536,9 +1545,7 @@ This does not change the name of the visited file (if any).  */)
       && !NILP (BVAR (current_buffer, auto_save_file_name)))
     call0 (intern ("rename-auto-save-file"));
 
-  /* Run buffer-list-update-hook.  */
-  if (!NILP (Vrun_hooks) && !current_buffer->inhibit_buffer_hooks)
-    call1 (Vrun_hooks, Qbuffer_list_update_hook);
+  run_buffer_list_update_hook (current_buffer);
 
   /* Refetch since that last call may have done GC.  */
   return BVAR (current_buffer, name);
@@ -1612,7 +1619,7 @@ exists, return the buffer `*scratch*' (creating it if necessary).  */)
       buf = Fget_buffer (scratch);
       if (NILP (buf))
         {
-          buf = Fget_buffer_create (scratch);
+          buf = Fget_buffer_create (scratch, Qnil);
           Fset_buffer_major_mode (buf);
         }
       return buf;
@@ -1636,7 +1643,7 @@ other_buffer_safely (Lisp_Object buffer)
   buf = Fget_buffer (scratch);
   if (NILP (buf))
     {
-      buf = Fget_buffer_create (scratch);
+      buf = Fget_buffer_create (scratch, Qnil);
       Fset_buffer_major_mode (buf);
     }
 
@@ -1713,7 +1720,9 @@ buffer to be killed as the current buffer.  If any of them returns nil,
 the buffer is not killed.  The hook `kill-buffer-hook' is run before the
 buffer is actually killed.  The buffer being killed will be current
 while the hook is running.  Functions called by any of these hooks are
-supposed to not change the current buffer.
+supposed to not change the current buffer.  Neither hook is run for
+internal or temporary buffers created by `get-buffer-create' or
+`generate-new-buffer' with argument INHIBIT-BUFFER-HOOKS non-nil.
 
 Any processes that have this buffer as the `process-buffer' are killed
 with SIGHUP.  This function calls `replace-buffer-in-windows' for
@@ -1973,9 +1982,7 @@ cleaning up all windows currently displaying the buffer to be killed. */)
   bset_width_table (b, Qnil);
   unblock_input ();
 
-  /* Run buffer-list-update-hook.  */
-  if (!NILP (Vrun_hooks) && !b->inhibit_buffer_hooks)
-    call1 (Vrun_hooks, Qbuffer_list_update_hook);
+  run_buffer_list_update_hook (b);
 
   return Qt;
 }
@@ -2015,9 +2022,7 @@ record_buffer (Lisp_Object buffer)
   fset_buffer_list (f, Fcons (buffer, Fdelq (buffer, f->buffer_list)));
   fset_buried_buffer_list (f, Fdelq (buffer, f->buried_buffer_list));
 
-  /* Run buffer-list-update-hook.  */
-  if (!NILP (Vrun_hooks) && !XBUFFER (buffer)->inhibit_buffer_hooks)
-    call1 (Vrun_hooks, Qbuffer_list_update_hook);
+  run_buffer_list_update_hook (XBUFFER (buffer));
 }
 
 
@@ -2054,9 +2059,7 @@ DEFUN ("bury-buffer-internal", Fbury_buffer_internal, Sbury_buffer_internal,
   fset_buried_buffer_list
     (f, Fcons (buffer, Fdelq (buffer, f->buried_buffer_list)));
 
-  /* Run buffer-list-update-hook.  */
-  if (!NILP (Vrun_hooks) && !XBUFFER (buffer)->inhibit_buffer_hooks)
-    call1 (Vrun_hooks, Qbuffer_list_update_hook);
+  run_buffer_list_update_hook (XBUFFER (buffer));
 
   return Qnil;
 }
@@ -5349,10 +5352,11 @@ init_buffer_once (void)
   Fput (Qkill_buffer_hook, Qpermanent_local, Qt);
 
   /* Super-magic invisible buffer.  */
-  Vprin1_to_string_buffer = Fget_buffer_create (build_pure_c_string (" prin1"));
+  Vprin1_to_string_buffer =
+    Fget_buffer_create (build_pure_c_string (" prin1"), Qt);
   Vbuffer_alist = Qnil;
 
-  Fset_buffer (Fget_buffer_create (build_pure_c_string ("*scratch*")));
+  Fset_buffer (Fget_buffer_create (build_pure_c_string ("*scratch*"), Qnil));
 
   inhibit_modification_hooks = 0;
 }
@@ -5397,7 +5401,7 @@ init_buffer (void)
 #endif /* USE_MMAP_FOR_BUFFERS */
 
   AUTO_STRING (scratch, "*scratch*");
-  Fset_buffer (Fget_buffer_create (scratch));
+  Fset_buffer (Fget_buffer_create (scratch, Qnil));
   if (NILP (BVAR (&buffer_defaults, enable_multibyte_characters)))
     Fset_buffer_multibyte (Qnil);
 
@@ -6300,9 +6304,14 @@ Use Custom to set this variable and update the display.  */);
   DEFVAR_LISP ("kill-buffer-query-functions", Vkill_buffer_query_functions,
                doc: /* List of functions called with no args to query before killing a buffer.
 The buffer being killed will be current while the functions are running.
+See `kill-buffer'.
 
 If any of them returns nil, the buffer is not killed.  Functions run by
-this hook are supposed to not change the current buffer.  */);
+this hook are supposed to not change the current buffer.
+
+This hook is not run for internal or temporary buffers created by
+`get-buffer-create' or `generate-new-buffer' with argument
+INHIBIT-BUFFER-HOOKS non-nil.  */);
   Vkill_buffer_query_functions = Qnil;
 
   DEFVAR_LISP ("change-major-mode-hook", Vchange_major_mode_hook,
@@ -6315,9 +6324,12 @@ The function `kill-all-local-variables' runs this before doing anything else.  *
                doc: /* Hook run when the buffer list changes.
 Functions (implicitly) running this hook are `get-buffer-create',
 `make-indirect-buffer', `rename-buffer', `kill-buffer', `bury-buffer'
-and `select-window'.  Functions run by this hook should avoid calling
-`select-window' with a nil NORECORD argument or `with-temp-buffer'
-since either may lead to infinite recursion.  */);
+and `select-window'.  This hook is not run for internal or temporary
+buffers created by `get-buffer-create' or `generate-new-buffer' with
+argument INHIBIT-BUFFER-HOOKS non-nil.
+
+Functions run by this hook should avoid calling `select-window' with a
+nil NORECORD argument since it may lead to infinite recursion.  */);
   Vbuffer_list_update_hook = Qnil;
   DEFSYM (Qbuffer_list_update_hook, "buffer-list-update-hook");
 
diff --git a/src/buffer.h b/src/buffer.h
index fe549c5dac1..b8c5162be4a 100644
--- a/src/buffer.h
+++ b/src/buffer.h
@@ -663,11 +663,11 @@ struct buffer
   /* Non-zero whenever the narrowing is changed in this buffer.  */
   bool_bf clip_changed : 1;
 
-  /* Non-zero for internally used temporary buffers that don't need to
-     run hooks kill-buffer-hook, buffer-list-update-hook, and
-     kill-buffer-query-functions.  This is used in coding.c to avoid
-     slowing down en/decoding when there are a lot of these hooks
-     defined.  */
+  /* Non-zero for internal or temporary buffers that don't need to
+     run hooks kill-buffer-hook, kill-buffer-query-functions, and
+     buffer-list-update-hook.  This is used in coding.c to avoid
+     slowing down en/decoding when a lot of these hooks are
+     defined, as well as by with-temp-buffer, for example.  */
   bool_bf inhibit_buffer_hooks : 1;
 
   /* List of overlays that end at or before the current center,
diff --git a/src/callproc.c b/src/callproc.c
index e3346e2eabb..3ecd6880274 100644
--- a/src/callproc.c
+++ b/src/callproc.c
@@ -100,6 +100,15 @@ enum
   };
 
 static Lisp_Object call_process (ptrdiff_t, Lisp_Object *, int, ptrdiff_t);
+
+#ifdef DOS_NT
+# define CHILD_SETUP_TYPE int
+#else
+# define CHILD_SETUP_TYPE _Noreturn void
+#endif
+
+static CHILD_SETUP_TYPE child_setup (int, int, int, char **, char **,
+                                     const char *);
 
 /* Return the current buffer's working directory, or the home
    directory if it's unreachable, as a string suitable for a system call.
@@ -300,8 +309,7 @@ call_process (ptrdiff_t nargs, Lisp_Object *args, int filefd,
 #ifdef MSDOS    /* Demacs 1.1.1 91/10/16 HIRANO Satoshi */
   char *tempfile = NULL;
 #else
-  sigset_t oldset;
-  pid_t pid;
+  pid_t pid = -1;
 #endif
   int child_errno;
   int fd_output, fd_error;
@@ -405,9 +413,8 @@ call_process (ptrdiff_t nargs, Lisp_Object *args, int filefd,
 
       if (! (NILP (buffer) || EQ (buffer, Qt) || FIXNUMP (buffer)))
         {
-          Lisp_Object spec_buffer;
-          spec_buffer = buffer;
-          buffer = Fget_buffer_create (buffer);
+          Lisp_Object spec_buffer = buffer;
+          buffer = Fget_buffer_create (buffer, Qnil);
           /* Mention the buffer name for a better error message.  */
           if (NILP (buffer))
             CHECK_BUFFER (spec_buffer);
@@ -542,8 +549,11 @@ call_process (ptrdiff_t nargs, Lisp_Object *args, int filefd,
       callproc_fd[CALLPROC_STDERR] = fd_error;
     }
 
+  char **env = make_environment_block (current_dir);
+
 #ifdef MSDOS /* MW, July 1993 */
-  status = child_setup (filefd, fd_output, fd_error, new_argv, 0, current_dir);
+  status = child_setup (filefd, fd_output, fd_error, new_argv, env,
+                        SSDATA (current_dir));
 
   if (status < 0)
     {
@@ -586,73 +596,10 @@ call_process (ptrdiff_t nargs, Lisp_Object *args, int filefd,
 
 #ifndef MSDOS
 
-  block_input ();
-  block_child_signal (&oldset);
-
-#ifdef WINDOWSNT
-  pid = child_setup (filefd, fd_output, fd_error, new_argv, 0, current_dir);
-#else  /* not WINDOWSNT */
-
-  /* vfork, and prevent local vars from being clobbered by the vfork.  */
-  {
-    Lisp_Object volatile buffer_volatile = buffer;
-    Lisp_Object volatile coding_systems_volatile = coding_systems;
-    Lisp_Object volatile current_dir_volatile = current_dir;
-    bool volatile display_p_volatile = display_p;
-    int volatile fd_error_volatile = fd_error;
-    int volatile filefd_volatile = filefd;
-    ptrdiff_t volatile count_volatile = count;
-    ptrdiff_t volatile sa_avail_volatile = sa_avail;
-    ptrdiff_t volatile sa_count_volatile = sa_count;
-    char **volatile new_argv_volatile = new_argv;
-    int volatile callproc_fd_volatile[CALLPROC_FDS];
-    for (i = 0; i < CALLPROC_FDS; i++)
-      callproc_fd_volatile[i] = callproc_fd[i];
-
-    pid = vfork ();
-
-    buffer = buffer_volatile;
-    coding_systems = coding_systems_volatile;
-    current_dir = current_dir_volatile;
-    display_p = display_p_volatile;
-    fd_error = fd_error_volatile;
-    filefd = filefd_volatile;
-    count = count_volatile;
-    sa_avail = sa_avail_volatile;
-    sa_count = sa_count_volatile;
-    new_argv = new_argv_volatile;
-
-    for (i = 0; i < CALLPROC_FDS; i++)
-      callproc_fd[i] = callproc_fd_volatile[i];
-    fd_output = callproc_fd[CALLPROC_STDOUT];
-  }
-
-  if (pid == 0)
-    {
-#ifdef DARWIN_OS
-      /* Work around a macOS bug, where SIGCHLD is apparently
-         delivered to a vforked child instead of to its parent.  See:
-         https://lists.gnu.org/r/emacs-devel/2017-05/msg00342.html
-      */
-      signal (SIGCHLD, SIG_DFL);
-#endif
-
-      unblock_child_signal (&oldset);
-      dissociate_controlling_tty ();
-
-      /* Emacs ignores SIGPIPE, but the child should not.  */
-      signal (SIGPIPE, SIG_DFL);
-      /* Likewise for SIGPROF.  */
-#ifdef SIGPROF
-      signal (SIGPROF, SIG_DFL);
-#endif
-
-      child_setup (filefd, fd_output, fd_error, new_argv, 0, current_dir);
-    }
-
-#endif /* not WINDOWSNT */
-
-  child_errno = errno;
+  child_errno
+    = emacs_spawn (&pid, filefd, fd_output, fd_error, new_argv, env,
+                   SSDATA (current_dir), NULL);
+  eassert ((child_errno == 0) == (0 < pid));
 
   if (pid > 0)
     {
@@ -672,9 +619,6 @@ call_process (ptrdiff_t nargs, Lisp_Object *args, int filefd,
         }
     }
 
-  unblock_child_signal (&oldset);
-  unblock_input ();
-
   if (pid < 0)
     report_file_errno (CHILD_SETUP_ERROR_DESC, Qnil, child_errno);
 
@@ -1188,16 +1132,6 @@ exec_failed (char const *name, int err)
   _exit (err == ENOENT ? EXIT_ENOENT : EXIT_CANNOT_INVOKE);
 }
 
-#else
-
-/* Do nothing.  There is no need to fail, as DOS_NT platforms do not
-   fork and exec, and handle alloca exhaustion in a different way.  */
-
-static void
-exec_failed (char const *name, int err)
-{
-}
-
 #endif
 
 /* This is the last thing run in a newly forked inferior
@@ -1206,8 +1140,6 @@ exec_failed (char const *name, int err)
    Initialize inferior's priority, pgrp, connected dir and environment.
    then exec another program based on new_argv.
 
-   If SET_PGRP, put the subprocess into a separate process group.
-
    CURRENT_DIR is an elisp string giving the path of the current
    directory the subprocess should have.  Since we can't really signal
    a decent error from within the child, this should be verified as an
@@ -1217,12 +1149,10 @@ exec_failed (char const *name, int err)
    On MS-Windows, either return a pid or return -1 and set errno.
    On MS-DOS, either return an exit status or signal an error.  */
 
-CHILD_SETUP_TYPE
-child_setup (int in, int out, int err, char **new_argv, bool set_pgrp,
-             Lisp_Object current_dir)
+static CHILD_SETUP_TYPE
+child_setup (int in, int out, int err, char **new_argv, char **env,
+             const char *current_dir)
 {
-  char **env;
-  char *pwd_var;
 #ifdef WINDOWSNT
   int cpid;
   HANDLE handles[3];
@@ -1236,24 +1166,6 @@ child_setup (int in, int out, int err, char **new_argv, bool set_pgrp,
      src/alloca.c) it is safe because that changes the superior's
      static variables as if the superior had done alloca and will be
      cleaned up in the usual way. */
-  {
-    char *temp;
-    ptrdiff_t i;
-
-    i = SBYTES (current_dir);
-#ifdef MSDOS
-    /* MSDOS must have all environment variables malloc'ed, because
-       low-level libc functions that launch subsidiary processes rely
-       on that.  */
-    pwd_var = xmalloc (i + 5);
-#else
-    if (MAX_ALLOCA - 5 < i)
-      exec_failed (new_argv[0], ENOMEM);
-    pwd_var = alloca (i + 5);
-#endif
-    temp = pwd_var + 4;
-    memcpy (pwd_var, "PWD=", 4);
-    lispstpcpy (temp, current_dir);
 
 #ifndef DOS_NT
     /* We can't signal an Elisp error here; we're in a vfork.  Since
@@ -1261,101 +1173,13 @@ child_setup (int in, int out, int err, char **new_argv, bool set_pgrp,
        should only return an error if the directory's permissions
        are changed between the check and this chdir, but we should
        at least check.  */
-    if (chdir (temp) < 0)
+    if (chdir (current_dir) < 0)
       _exit (EXIT_CANCELED);
-#else /* DOS_NT */
-    /* Get past the drive letter, so that d:/ is left alone.  */
-    if (i > 2 && IS_DEVICE_SEP (temp[1]) && IS_DIRECTORY_SEP (temp[2]))
-      {
-        temp += 2;
-        i -= 2;
-      }
-#endif /* DOS_NT */
-
-    /* Strip trailing slashes for PWD, but leave "/" and "//" alone.  */
-    while (i > 2 && IS_DIRECTORY_SEP (temp[i - 1]))
-      temp[--i] = 0;
-  }
-
-  /* Set `env' to a vector of the strings in the environment.  */
-  {
-    register Lisp_Object tem;
-    register char **new_env;
-    char **p, **q;
-    register int new_length;
-    Lisp_Object display = Qnil;
-
-    new_length = 0;
-
-    for (tem = Vprocess_environment;
-         CONSP (tem) && STRINGP (XCAR (tem));
-         tem = XCDR (tem))
-      {
-        if (strncmp (SSDATA (XCAR (tem)), "DISPLAY", 7) == 0
-            && (SDATA (XCAR (tem)) [7] == '\0'
-                || SDATA (XCAR (tem)) [7] == '='))
-          /* DISPLAY is specified in process-environment.  */
-          display = Qt;
-        new_length++;
-      }
-
-    /* If not provided yet, use the frame's DISPLAY.  */
-    if (NILP (display))
-      {
-        Lisp_Object tmp = Fframe_parameter (selected_frame, Qdisplay);
-        if (!STRINGP (tmp) && CONSP (Vinitial_environment))
-          /* If still not found, Look for DISPLAY in Vinitial_environment.  */
-          tmp = Fgetenv_internal (build_string ("DISPLAY"),
-                                  Vinitial_environment);
-        if (STRINGP (tmp))
-          {
-            display = tmp;
-            new_length++;
-          }
-      }
-
-    /* new_length + 2 to include PWD and terminating 0.  */
-    if (MAX_ALLOCA / sizeof *env - 2 < new_length)
-      exec_failed (new_argv[0], ENOMEM);
-    env = new_env = alloca ((new_length + 2) * sizeof *env);
-    /* If we have a PWD envvar, pass one down,
-       but with corrected value.  */
-    if (egetenv ("PWD"))
-      *new_env++ = pwd_var;
-
-    if (STRINGP (display))
-      {
-        if (MAX_ALLOCA - sizeof "DISPLAY=" < SBYTES (display))
-          exec_failed (new_argv[0], ENOMEM);
-        char *vdata = alloca (sizeof "DISPLAY=" + SBYTES (display));
-        lispstpcpy (stpcpy (vdata, "DISPLAY="), display);
-        new_env = add_env (env, new_env, vdata);
-      }
-
-    /* Overrides.  */
-    for (tem = Vprocess_environment;
-         CONSP (tem) && STRINGP (XCAR (tem));
-         tem = XCDR (tem))
-      new_env = add_env (env, new_env, SSDATA (XCAR (tem)));
-
-    *new_env = 0;
-
-    /* Remove variable names without values.  */
-    p = q = env;
-    while (*p != 0)
-      {
-        while (*q != 0 && strchr (*q, '=') == NULL)
-          q++;
-        *p = *q++;
-        if (*p != 0)
-          p++;
-      }
-  }
-
+#endif
 
 #ifdef WINDOWSNT
   prepare_standard_handles (in, out, err, handles);
-  set_process_dir (SSDATA (current_dir));
+  set_process_dir (current_dir);
   /* Spawn the child.  (See w32proc.c:sys_spawnve).  */
   cpid = spawnve (_P_NOWAIT, new_argv[0], new_argv, env);
   reset_standard_handles (in, out, err, handles);
@@ -1391,6 +1215,183 @@ child_setup (int in, int out, int err, char **new_argv, bool set_pgrp,
 #endif  /* not WINDOWSNT */
 }
 
+/* Start a new asynchronous subprocess.  If successful, return zero
+   and store the process identifier of the new process in *NEWPID.
+   Use STDIN, STDOUT, and STDERR as standard streams for the new
+   process.  Use ARGV as argument vector for the new process; use
+   process image file ARGV[0].  Use ENVP for the environment block for
+   the new process.  Use CWD as working directory for the new process.
+   If PTY is not NULL, it must be a pseudoterminal device.  If PTY is
+   NULL, don't perform any terminal setup.  */
+
+int
+emacs_spawn (pid_t *newpid, int std_in, int std_out, int std_err,
+             char **argv, char **envp, const char *cwd, const char *pty)
+{
+  sigset_t oldset;
+  int pid;
+
+  block_input ();
+  block_child_signal (&oldset);
+
+#ifndef WINDOWSNT
+  /* vfork, and prevent local vars from being clobbered by the vfork.  */
+  pid_t *volatile newpid_volatile = newpid;
+  const char *volatile cwd_volatile = cwd;
+  const char *volatile pty_volatile = pty;
+  char **volatile argv_volatile = argv;
+  int volatile stdin_volatile = std_in;
+  int volatile stdout_volatile = std_out;
+  int volatile stderr_volatile = std_err;
+  char **volatile envp_volatile = envp;
+
+#ifdef DARWIN_OS
+  /* Darwin doesn't let us run setsid after a vfork, so use fork when
+     necessary.  Below, we reset SIGCHLD handling after a vfork, as
+     apparently macOS can mistakenly deliver SIGCHLD to the child.  */
+  if (pty != NULL)
+    pid = fork ();
+  else
+    pid = vfork ();
+#else
+  pid = vfork ();
+#endif
+
+  newpid = newpid_volatile;
+  cwd = cwd_volatile;
+  pty = pty_volatile;
+  argv = argv_volatile;
+  std_in = stdin_volatile;
+  std_out = stdout_volatile;
+  std_err = stderr_volatile;
+  envp = envp_volatile;
+
+  if (pid == 0)
+#endif /* not WINDOWSNT */
+    {
+      bool pty_flag = pty != NULL;
+      /* Make the pty be the controlling terminal of the process.  */
+#ifdef HAVE_PTYS
+      dissociate_controlling_tty ();
+
+      /* Make the pty's terminal the controlling terminal.  */
+      if (pty_flag && std_in >= 0)
+        {
+#ifdef TIOCSCTTY
+          /* We ignore the return value
+             because faith@cs.unc.edu says that is necessary on Linux.  */
+          ioctl (std_in, TIOCSCTTY, 0);
+#endif
+        }
+#if defined (LDISC1)
+      if (pty_flag && std_in >= 0)
+        {
+          struct termios t;
+          tcgetattr (std_in, &t);
+          t.c_lflag = LDISC1;
+          if (tcsetattr (std_in, TCSANOW, &t) < 0)
+            emacs_perror ("create_process/tcsetattr LDISC1");
+        }
+#else
+#if defined (NTTYDISC) && defined (TIOCSETD)
+      if (pty_flag && std_in >= 0)
+        {
+          /* Use new line discipline.  */
+          int ldisc = NTTYDISC;
+          ioctl (std_in, TIOCSETD, &ldisc);
+        }
+#endif
+#endif
+
+#if !defined (DONT_REOPEN_PTY)
+/*** There is a suggestion that this ought to be a
+     conditional on TIOCSPGRP, or !defined TIOCSCTTY.
+     Trying the latter gave the wrong results on Debian GNU/Linux 1.1;
+     that system does seem to need this code, even though
+     both TIOCSCTTY is defined.  */
+        /* Now close the pty (if we had it open) and reopen it.
+           This makes the pty the controlling terminal of the subprocess.  */
+      if (pty_flag)
+        {
+
+          /* I wonder if emacs_close (emacs_open (pty, ...))
+             would work?  */
+          if (std_in >= 0)
+            emacs_close (std_in);
+          std_out = std_in = emacs_open (pty, O_RDWR, 0);
+
+          if (std_in < 0)
+            {
+              emacs_perror (pty);
+              _exit (EXIT_CANCELED);
+            }
+
+        }
+#endif /* not DONT_REOPEN_PTY */
+
+#ifdef SETUP_SLAVE_PTY
+      if (pty_flag)
+        {
+          SETUP_SLAVE_PTY;
+        }
+#endif /* SETUP_SLAVE_PTY */
+#endif /* HAVE_PTYS */
+
+#ifdef DARWIN_OS
+      /* Work around a macOS bug, where SIGCHLD is apparently
+         delivered to a vforked child instead of to its parent.  See:
+         https://lists.gnu.org/r/emacs-devel/2017-05/msg00342.html
+      */
+      signal (SIGCHLD, SIG_DFL);
+#endif
+
+      signal (SIGINT, SIG_DFL);
+      signal (SIGQUIT, SIG_DFL);
+#ifdef SIGPROF
+      signal (SIGPROF, SIG_DFL);
+#endif
+
+      /* Emacs ignores SIGPIPE, but the child should not.  */
+      signal (SIGPIPE, SIG_DFL);
+      /* Likewise for SIGPROF.  */
+#ifdef SIGPROF
+      signal (SIGPROF, SIG_DFL);
+#endif
+
+      /* Stop blocking SIGCHLD in the child.  */
+      unblock_child_signal (&oldset);
+
+      if (pty_flag)
+        child_setup_tty (std_out);
+
+      if (std_err < 0)
+        std_err = std_out;
+#ifdef WINDOWSNT
+      pid = child_setup (std_in, std_out, std_err, argv, envp, cwd);
+#else  /* not WINDOWSNT */
+      child_setup (std_in, std_out, std_err, argv, envp, cwd);
+#endif /* not WINDOWSNT */
+    }
+
+  /* Back in the parent process.  */
+
+  int vfork_error = pid < 0 ? errno : 0;
+
+  /* Stop blocking in the parent.  */
+  unblock_child_signal (&oldset);
+  unblock_input ();
+
+  if (pid < 0)
+    {
+      eassert (0 < vfork_error);
+      return vfork_error;
+    }
+
+  eassert (0 < pid);
+  *newpid = pid;
+  return 0;
+}
+
 static bool
 getenv_internal_1 (const char *var, ptrdiff_t varlen, char **value,
                    ptrdiff_t *valuelen, Lisp_Object env)
@@ -1514,6 +1515,119 @@ egetenv_internal (const char *var, ptrdiff_t len)
     return 0;
 }
 
+/* Create a new environment block.  You can pass the returned pointer
+   to `execve'.  Add unwind protections for all newly-allocated
+   objects.  Don't call any Lisp code or the garbage collector while
+   the block is active.  */
+
+char **
+make_environment_block (Lisp_Object current_dir)
+{
+  char **env;
+  char *pwd_var;
+
+  {
+    char *temp;
+    ptrdiff_t i;
+
+    i = SBYTES (current_dir);
+    pwd_var = xmalloc (i + 5);
+    record_unwind_protect_ptr (xfree, pwd_var);
+    temp = pwd_var + 4;
+    memcpy (pwd_var, "PWD=", 4);
+    lispstpcpy (temp, current_dir);
+
+#ifdef DOS_NT
+    /* Get past the drive letter, so that d:/ is left alone.  */
+    if (i > 2 && IS_DEVICE_SEP (temp[1]) && IS_DIRECTORY_SEP (temp[2]))
+      {
+        temp += 2;
+        i -= 2;
+      }
+#endif /* DOS_NT */
+
+    /* Strip trailing slashes for PWD, but leave "/" and "//" alone.  */
+    while (i > 2 && IS_DIRECTORY_SEP (temp[i - 1]))
+      temp[--i] = 0;
+  }
+
+  /* Set `env' to a vector of the strings in the environment.  */
+
+  {
+    register Lisp_Object tem;
+    register char **new_env;
+    char **p, **q;
+    register int new_length;
+    Lisp_Object display = Qnil;
+
+    new_length = 0;
+
+    for (tem = Vprocess_environment;
+         CONSP (tem) && STRINGP (XCAR (tem));
+         tem = XCDR (tem))
+      {
+        if (strncmp (SSDATA (XCAR (tem)), "DISPLAY", 7) == 0
+            && (SDATA (XCAR (tem)) [7] == '\0'
+                || SDATA (XCAR (tem)) [7] == '='))
+          /* DISPLAY is specified in process-environment.  */
+          display = Qt;
+        new_length++;
+      }
+
+    /* If not provided yet, use the frame's DISPLAY.  */
+    if (NILP (display))
+      {
+        Lisp_Object tmp = Fframe_parameter (selected_frame, Qdisplay);
+        if (!STRINGP (tmp) && CONSP (Vinitial_environment))
+          /* If still not found, Look for DISPLAY in Vinitial_environment.  */
+          tmp = Fgetenv_internal (build_string ("DISPLAY"),
+                                  Vinitial_environment);
+        if (STRINGP (tmp))
+          {
+            display = tmp;
+            new_length++;
+          }
+      }
+
+    /* new_length + 2 to include PWD and terminating 0.  */
+    env = new_env = xnmalloc (new_length + 2, sizeof *env);
+    record_unwind_protect_ptr (xfree, env);
+    /* If we have a PWD envvar, pass one down,
+       but with corrected value.  */
+    if (egetenv ("PWD"))
+      *new_env++ = pwd_var;
+
+    if (STRINGP (display))
+      {
+        char *vdata = xmalloc (sizeof "DISPLAY=" + SBYTES (display));
+        record_unwind_protect_ptr (xfree, vdata);
+        lispstpcpy (stpcpy (vdata, "DISPLAY="), display);
+        new_env = add_env (env, new_env, vdata);
+      }
+
+    /* Overrides.  */
+    for (tem = Vprocess_environment;
+         CONSP (tem) && STRINGP (XCAR (tem));
+         tem = XCDR (tem))
+      new_env = add_env (env, new_env, SSDATA (XCAR (tem)));
+
+    *new_env = 0;
+
+    /* Remove variable names without values.  */
+    p = q = env;
+    while (*p != 0)
+      {
+        while (*q != 0 && strchr (*q, '=') == NULL)
+          q++;
+        *p = *q++;
+        if (*p != 0)
+          p++;
+      }
+  }
+
+  return env;
+}
+
 
 /* This is run before init_cmdargs.  */
 
diff --git a/src/coding.c b/src/coding.c
index 2142e7fa518..8c2443889d4 100644
--- a/src/coding.c
+++ b/src/coding.c
@@ -7821,7 +7821,7 @@ encode_coding (struct coding_system *coding)
 
 /* A string that serves as name of the reusable work buffer, and as base
    name of temporary work buffers used for code-conversion operations.  */
-Lisp_Object Vcode_conversion_workbuf_name;
+static Lisp_Object Vcode_conversion_workbuf_name;
 
 /* The reusable working buffer, created once and never killed.  */
 static Lisp_Object Vcode_conversion_reused_workbuf;
@@ -7839,7 +7839,7 @@ code_conversion_restore (Lisp_Object arg)
   if (! NILP (workbuf))
     {
       if (EQ (workbuf, Vcode_conversion_reused_workbuf))
-        reused_workbuf_in_use = 0;
+        reused_workbuf_in_use = false;
       else
         Fkill_buffer (workbuf);
     }
@@ -7857,13 +7857,13 @@ code_conversion_save (bool with_work_buf, bool multibyte)
         {
           Lisp_Object name
             = Fgenerate_new_buffer_name (Vcode_conversion_workbuf_name, Qnil);
-          workbuf = Fget_buffer_create (name);
+          workbuf = Fget_buffer_create (name, Qt);
         }
       else
         {
           if (NILP (Fbuffer_live_p (Vcode_conversion_reused_workbuf)))
             Vcode_conversion_reused_workbuf
-              = Fget_buffer_create (Vcode_conversion_workbuf_name);
+              = Fget_buffer_create (Vcode_conversion_workbuf_name, Qt);
           workbuf = Vcode_conversion_reused_workbuf;
         }
     }
@@ -7881,7 +7881,7 @@ code_conversion_save (bool with_work_buf, bool multibyte)
       bset_undo_list (current_buffer, Qt);
       bset_enable_multibyte_characters (current_buffer, multibyte ? Qt : Qnil);
       if (EQ (workbuf, Vcode_conversion_reused_workbuf))
-        reused_workbuf_in_use = 1;
+        reused_workbuf_in_use = true;
       set_buffer_internal (current);
     }
 
@@ -10354,8 +10354,8 @@ decode_file_name (Lisp_Object fname)
 #endif
 }
 
-Lisp_Object
-encode_file_name (Lisp_Object fname)
+static Lisp_Object
+encode_file_name_1 (Lisp_Object fname)
 {
   /* This is especially important during bootstrap and dumping, when
      file-name encoding is not yet known, and therefore any non-ASCII
@@ -10380,6 +10380,19 @@ encode_file_name (Lisp_Object fname)
 #endif
 }
 
+Lisp_Object
+encode_file_name (Lisp_Object fname)
+{
+  Lisp_Object encoded = encode_file_name_1 (fname);
+  /* No system accepts NUL bytes in filenames.  Allowing them can
+     cause subtle bugs because the system would silently use a
+     different filename than expected.  Perform this check after
+     encoding to not miss NUL bytes introduced through encoding.  */
+  CHECK_TYPE (memchr (SSDATA (encoded), '\0', SBYTES (encoded)) == NULL,
+              Qfilenamep, fname);
+  return encoded;
+}
+
 DEFUN ("decode-coding-string", Fdecode_coding_string, Sdecode_coding_string,
        2, 4, 0,
        doc: /* Decode STRING which is encoded in CODING-SYSTEM, and return the result.
@@ -11639,7 +11652,7 @@ syms_of_coding (void)
   staticpro (&Vcode_conversion_workbuf_name);
   Vcode_conversion_workbuf_name = build_pure_c_string (" *code-conversion-work*");
 
-  reused_workbuf_in_use = 0;
+  reused_workbuf_in_use = false;
   PDUMPER_REMEMBER_SCALAR (reused_workbuf_in_use);
 
   DEFSYM (Qcharset, "charset");
@@ -11780,6 +11793,7 @@ syms_of_coding (void)
   DEFSYM (Qignored, "ignored");
 
   DEFSYM (Qutf_8_string_p, "utf-8-string-p");
+  DEFSYM (Qfilenamep, "filenamep");
 
   defsubr (&Scoding_system_p);
   defsubr (&Sread_coding_system);
diff --git a/src/coding.h b/src/coding.h
index 4973cf89eb1..9ad1e954f8d 100644
--- a/src/coding.h
+++ b/src/coding.h
@@ -97,9 +97,6 @@ enum define_coding_undecided_arg_index
 
 extern Lisp_Object Vcoding_system_hash_table;
 
-/* Name (or base name) of work buffer for code conversion.  */
-extern Lisp_Object Vcode_conversion_workbuf_name;
-
 /* Enumeration of index to an attribute vector of a coding system.  */
 
 enum coding_attr_index
diff --git a/src/dispnew.c b/src/dispnew.c
index 1aee18e7477..893e49160de 100644
--- a/src/dispnew.c
+++ b/src/dispnew.c
@@ -6057,6 +6057,8 @@ sit_for (Lisp_Object timeout, bool reading, int display_option)
   intmax_t sec;
   int nsec;
   bool do_display = display_option > 0;
+  bool curbuf_eq_winbuf
+    = (current_buffer == XBUFFER (XWINDOW (selected_window)->contents));
 
   swallow_events (do_display);
 
@@ -6111,6 +6113,13 @@ sit_for (Lisp_Object timeout, bool reading, int display_option)
   wait_reading_process_output (sec, nsec, reading ? -1 : 1, do_display,
                                Qnil, NULL, 0);
 
+  if (reading && curbuf_eq_winbuf)
+    /* Timers and process filters/sentinels may have changed the selected
+       window (e.g. in response to a connection from emacsclient), in which
+       case we should follow it (unless we weren't in the selected-window's
+       buffer to start with).  */
+    set_buffer_internal (XBUFFER (XWINDOW (selected_window)->contents));
+
   return detect_input_pending () ? Qnil : Qt;
 }
 
diff --git a/src/fileio.c b/src/fileio.c
index c97f4daf20c..23b4523c944 100644
--- a/src/fileio.c
+++ b/src/fileio.c
@@ -3050,7 +3050,6 @@ file_accessible_directory_p (Lisp_Object file)
   ptrdiff_t len = SBYTES (file);
   char const *dir;
   bool ok;
-  int saved_errno;
   USE_SAFE_ALLOCA;
 
   /* Normally a file "FOO" is an accessible directory if "FOO/." exists.
@@ -3075,9 +3074,7 @@ file_accessible_directory_p (Lisp_Object file)
     }
 
   ok = file_access_p (dir, F_OK);
-  saved_errno = errno;
   SAFE_FREE ();
-  errno = saved_errno;
   return ok;
 #endif  /* !DOS_NT */
 }
@@ -4004,7 +4001,7 @@ by calling `format-decode', which see.  */)
 
                   record_unwind_current_buffer ();
 
-                  workbuf = Fget_buffer_create (name);
+                  workbuf = Fget_buffer_create (name, Qt);
                   buf = XBUFFER (workbuf);
 
                   delete_all_overlays (buf);
@@ -5752,7 +5749,7 @@ auto_save_error (Lisp_Object error_val)
   Lisp_Object msg = CALLN (Fformat, format, BVAR (current_buffer, name),
                            Ferror_message_string (error_val));
   call3 (intern ("display-warning"),
-         intern ("auto-save"), msg, intern ("error"));
+         intern ("auto-save"), msg, intern (":error"));
 
   return Qnil;
 }
diff --git a/src/gtkutil.c b/src/gtkutil.c
index a62616bbfc6..9ab844e8311 100644
--- a/src/gtkutil.c
+++ b/src/gtkutil.c
@@ -3313,14 +3313,11 @@ xg_get_menu_item_label (GtkMenuItem *witem)
 static bool
 xg_item_label_same_p (GtkMenuItem *witem, const char *label)
 {
-  bool is_same = 0;
   char *utf8_label = get_utf8_string (label);
   const char *old_label = witem ? xg_get_menu_item_label (witem) : 0;
 
-  if (! old_label && ! utf8_label)
-    is_same = 1;
-  else if (old_label && utf8_label)
-    is_same = strcmp (utf8_label, old_label) == 0;
+  bool is_same = (!old_label == !utf8_label
+                  && (!old_label || strcmp (utf8_label, old_label) == 0));
 
   if (utf8_label) g_free (utf8_label);
 
diff --git a/src/image.c b/src/image.c
index b62e7bcd2ef..8843852f71d 100644
--- a/src/image.c
+++ b/src/image.c
@@ -1904,37 +1904,61 @@ which is then usually a filename.  */)
 }
 
 static size_t
-image_frame_cache_size (struct frame *f)
+image_size_in_bytes (struct image *img)
 {
-  size_t total = 0;
+  size_t size = 0;
+
 #if defined USE_CAIRO
-  struct image_cache *c = FRAME_IMAGE_CACHE (f);
+  Emacs_Pixmap pm = img->pixmap;
+  if (pm)
+    size += pm->height * pm->bytes_per_line;
+  Emacs_Pixmap msk = img->mask;
+  if (msk)
+    size += msk->height * msk->bytes_per_line;
 
-  if (!c)
-    return 0;
+#elif defined HAVE_X_WINDOWS
+  /* Use a nominal depth of 24 bpp for pixmap and 1 bpp for mask,
+     to avoid having to query the server. */
+  if (img->pixmap != NO_PIXMAP)
+    size += img->width * img->height * 3;
+  if (img->mask != NO_PIXMAP)
+    size += img->width * img->height / 8;
+
+  if (img->ximg && img->ximg->data)
+    size += img->ximg->bytes_per_line * img->ximg->height;
+  if (img->mask_img && img->mask_img->data)
+    size += img->mask_img->bytes_per_line * img->mask_img->height;
 
-  for (ptrdiff_t i = 0; i < c->used; ++i)
-    {
-      struct image *img = c->images[i];
+#elif defined HAVE_NS
+  if (img->pixmap)
+    size += ns_image_size_in_bytes (img->pixmap);
+  if (img->mask)
+    size += ns_image_size_in_bytes (img->mask);
 
-      if (img && img->pixmap && img->pixmap != NO_PIXMAP)
-        total += img->pixmap->width * img->pixmap->height  *
-          img->pixmap->bits_per_pixel / 8;
-    }
 #elif defined HAVE_NTGUI
-  struct image_cache *c = FRAME_IMAGE_CACHE (f);
+  if (img->pixmap)
+    size += w32_image_size (img->pixmap);
+  if (img->mask)
+    size += w32_image_size (img->mask);
+
+#endif
+
+  return size;
+}
 
+static size_t
+image_frame_cache_size (struct frame *f)
+{
+  struct image_cache *c = FRAME_IMAGE_CACHE (f);
   if (!c)
     return 0;
 
+  size_t total = 0;
   for (ptrdiff_t i = 0; i < c->used; ++i)
     {
       struct image *img = c->images[i];
-
-      if (img && img->pixmap && img->pixmap != NO_PIXMAP)
-        total += w32_image_size (img);
+      total += img ? image_size_in_bytes (img) : 0;
     }
-#endif
   return total;
 }
 
@@ -2501,7 +2525,7 @@ lookup_image (struct frame *f, Lisp_Object spec, int face_id)
 
   /* Look up SPEC in the hash table of the image cache.  */
   hash = sxhash (spec);
-  img = search_image_cache (f, spec, hash, foreground, background, true);
+  img = search_image_cache (f, spec, hash, foreground, background, false);
   if (img && img->load_failed_p)
     {
       free_image (f, img);
@@ -9897,8 +9921,9 @@ svg_load (struct frame *f, struct image *img)
         }
       /* If the file was slurped into memory properly, parse it.  */
       if (!STRINGP (base_uri))
-        base_uri = ENCODE_FILE (file);
-      success_p = svg_load_image (f, img, contents, size, SSDATA (base_uri));
+        base_uri = file;
+      success_p = svg_load_image (f, img, contents, size,
+                                  SSDATA (ENCODE_FILE (base_uri)));
       xfree (contents);
     }
   /* Else it's not a file, it's a Lisp object.  Load the image from a
@@ -9916,7 +9941,8 @@ svg_load (struct frame *f, struct image *img)
       if (!STRINGP (base_uri))
         base_uri = BVAR (current_buffer, filename);
       success_p = svg_load_image (f, img, SSDATA (data), SBYTES (data),
-                                  (NILP (base_uri) ? NULL : SSDATA (base_uri)));
+                                  (STRINGP (base_uri) ?
+                                   SSDATA (ENCODE_FILE (base_uri)) : NULL));
     }
 
   return success_p;
diff --git a/src/lisp.h b/src/lisp.h
index e83304462fa..501bcd14a6f 100644
--- a/src/lisp.h
+++ b/src/lisp.h
@@ -4493,14 +4493,14 @@ extern void setup_process_coding_systems (Lisp_Object);
 
 /* Defined in callproc.c.  */
 #ifdef DOS_NT
-# define CHILD_SETUP_TYPE int
 # define CHILD_SETUP_ERROR_DESC "Spawning child process"
 #else
-# define CHILD_SETUP_TYPE _Noreturn void
 # define CHILD_SETUP_ERROR_DESC "Doing vfork"
 #endif
 
-extern CHILD_SETUP_TYPE child_setup (int, int, int, char **, bool, Lisp_Object);
+extern int emacs_spawn (pid_t *, int, int, int, char **, char **, const char *,
+                        const char *);
+extern char **make_environment_block (Lisp_Object);
 extern void init_callproc_1 (void);
 extern void init_callproc (void);
 extern void set_initial_environment (void);
diff --git a/src/minibuf.c b/src/minibuf.c
index fc3fd92a880..1940564a80a 100644
--- a/src/minibuf.c
+++ b/src/minibuf.c
@@ -809,7 +809,7 @@ get_minibuffer (EMACS_INT depth)
       static char const name_fmt[] = " *Minibuf-%"pI"d*";
       char name[sizeof name_fmt + INT_STRLEN_BOUND (EMACS_INT)];
       AUTO_STRING_WITH_LEN (lname, name, sprintf (name, name_fmt, depth));
-      buf = Fget_buffer_create (lname);
+      buf = Fget_buffer_create (lname, Qnil);
 
       /* Although the buffer's name starts with a space, undo should be
          enabled in it.  */
diff --git a/src/nsfns.m b/src/nsfns.m
index c7956497c4c..f3c5a9ef679 100644
--- a/src/nsfns.m
+++ b/src/nsfns.m
@@ -456,7 +456,7 @@ ns_set_name (struct frame *f, Lisp_Object name, int explicit)
 static void
 ns_set_represented_filename (struct frame *f)
 {
-  Lisp_Object filename, encoded_filename;
+  Lisp_Object filename;
   Lisp_Object buf = XWINDOW (f->selected_window)->contents;
   NSAutoreleasePool *pool;
   NSString *fstr;
@@ -473,9 +473,7 @@ ns_set_represented_filename (struct frame *f)
 
   if (! NILP (filename))
     {
-      encoded_filename = ENCODE_UTF_8 (filename);
-
-      fstr = [NSString stringWithLispString:encoded_filename];
+      fstr = [NSString stringWithLispString:filename];
       if (fstr == nil) fstr = @"";
     }
   else
@@ -3012,7 +3010,7 @@ DEFUN ("ns-show-character-palette",
 #endif
 
 
-/* Whether N bytes at STR are in the [0,127] range.  */
+/* Whether N bytes at STR are in the [1,127] range.  */
 static bool
 all_nonzero_ascii (unsigned char *str, ptrdiff_t n)
 {
diff --git a/src/nsfont.m b/src/nsfont.m
index 378a6408401..9e4caca9102 100644
--- a/src/nsfont.m
+++ b/src/nsfont.m
@@ -329,7 +329,7 @@ static NSString
 {
     Lisp_Object script = assq_no_quit (XCAR (otf), Votf_script_alist);
     return CONSP (script)
-        ? [NSString stringWithUTF8String: SSDATA (SYMBOL_NAME (XCDR ((script))))]
+        ? [NSString stringWithLispString: SYMBOL_NAME (XCDR ((script)))]
         : @"";
 }
 
@@ -345,7 +345,7 @@ static NSString
         if (!strncmp (SSDATA (r), reg, SBYTES (r)))
           {
             script = XCDR (XCAR (rts));
-            return [NSString stringWithUTF8String: SSDATA (SYMBOL_NAME (script))];
+            return [NSString stringWithLispString: SYMBOL_NAME (script)];
           }
         rts = XCDR (rts);
       }
@@ -370,8 +370,7 @@ static NSString
           {
             Lisp_Object key = XCAR (tmp), val = XCDR (tmp);
             if (EQ (key, QCscript) && SYMBOLP (val))
-                return [NSString stringWithUTF8String:
-                            SSDATA (SYMBOL_NAME (val))];
+                return [NSString stringWithLispString: SYMBOL_NAME (val)];
             if (EQ (key, QClang) && SYMBOLP (val))
                 return ns_lang_to_script (val);
             if (EQ (key, QCotf) && CONSP (val) && SYMBOLP (XCAR (val)))
diff --git a/src/nsimage.m b/src/nsimage.m
index da6f01cf6a3..c47a2b2d64a 100644
--- a/src/nsimage.m
+++ b/src/nsimage.m
@@ -235,6 +235,11 @@ ns_set_alpha (void *img, int x, int y, unsigned char a)
   [(EmacsImage *)img setAlphaAtX: x Y: y to: a];
 }
 
+size_t
+ns_image_size_in_bytes (void *img)
+{
+  return [(EmacsImage *)img sizeInBytes];
+}
 
 /* ==========================================================================
 
@@ -257,7 +262,7 @@ ns_set_alpha (void *img, int x, int y, unsigned char a)
   found = ENCODE_FILE (found);
 
   image = [[EmacsImage alloc] initByReferencingFile:
-                     [NSString stringWithUTF8String: SSDATA (found)]];
+                     [NSString stringWithLispString: found]];
 
   image->bmRep = nil;
 #ifdef NS_IMPL_COCOA
@@ -273,7 +278,7 @@ ns_set_alpha (void *img, int x, int y, unsigned char a)
 
   [image setSize: NSMakeSize([imgRep pixelsWide], [imgRep pixelsHigh])];
 
-  [image setName: [NSString stringWithUTF8String: SSDATA (file)]];
+  [image setName: [NSString stringWithLispString: file]];
 
   return image;
 }
@@ -610,5 +615,22 @@ ns_set_alpha (void *img, int x, int y, unsigned char a)
   smoothing = s;
 }
 
+/* Approximate allocated size of image in bytes.  */
+- (size_t) sizeInBytes
+{
+  size_t bytes = 0;
+  NSImageRep *rep;
+  NSEnumerator *reps = [[self representations] objectEnumerator];
+  while ((rep = (NSImageRep *) [reps nextObject]))
+    {
+      if ([rep respondsToSelector: @selector (bytesPerRow)])
+        {
+          NSBitmapImageRep *bmr = (NSBitmapImageRep *) rep;
+          bytes += [bmr bytesPerRow] * [bmr numberOfPlanes] * [bmr pixelsHigh];
+        }
+    }
+  return bytes;
+}
+
 
 @end
diff --git a/src/nsmenu.m b/src/nsmenu.m
index a286a80da17..efad978316e 100644
--- a/src/nsmenu.m
+++ b/src/nsmenu.m
@@ -970,7 +970,7 @@ ns_menu_show (struct frame *f, int x, int y, int menuflags,
     }
 
   pmenu = [[EmacsMenu alloc] initWithTitle:
-                               [NSString stringWithUTF8String: SSDATA (title)]];
+                               [NSString stringWithLispString: title]];
   [pmenu fillWithWidgetValue: first_wv->contents];
   free_menubar_widget_value_tree (first_wv);
   unbind_to (specpdl_count, Qnil);
diff --git a/src/nsselect.m b/src/nsselect.m
index 7b1937f5d99..95fce4d0f78 100644
--- a/src/nsselect.m
+++ b/src/nsselect.m
@@ -58,7 +58,7 @@ symbol_to_nsstring (Lisp_Object sym)
   if (EQ (sym, QPRIMARY))     return NXPrimaryPboard;
   if (EQ (sym, QSECONDARY))   return NXSecondaryPboard;
   if (EQ (sym, QTEXT))        return NSPasteboardTypeString;
-  return [NSString stringWithUTF8String: SSDATA (SYMBOL_NAME (sym))];
+  return [NSString stringWithLispString: SYMBOL_NAME (sym)];
 }
 
 static NSPasteboard *
@@ -170,17 +170,12 @@ ns_string_to_pasteboard_internal (id pb, Lisp_Object str, NSString *gtype)
     }
   else
     {
-      char *utfStr;
       NSString *type, *nsStr;
       NSEnumerator *tenum;
 
       CHECK_STRING (str);
 
-      utfStr = SSDATA (str);
-      nsStr = [[NSString alloc] initWithBytesNoCopy: utfStr
-                                             length: SBYTES (str)
-                                           encoding: NSUTF8StringEncoding
-                                       freeWhenDone: NO];
+      nsStr = [NSString stringWithLispString: str];
       // FIXME: Why those 2 different code paths?
       if (gtype == nil)
         {
@@ -196,7 +191,6 @@ ns_string_to_pasteboard_internal (id pb, Lisp_Object str, NSString *gtype)
           eassert (gtype == NSPasteboardTypeString);
           [pb setString: nsStr forType: gtype];
         }
-      [nsStr release];
       ns_store_pb_change_count (pb);
     }
 }
diff --git a/src/nsterm.h b/src/nsterm.h
index f292993d8f7..94472ec1070 100644
--- a/src/nsterm.h
+++ b/src/nsterm.h
@@ -666,6 +666,7 @@ typedef id instancetype;
 - (BOOL)setFrame: (unsigned int) index;
 - (void)setTransform: (double[3][3]) m;
 - (void)setSmoothing: (BOOL)s;
+- (size_t)sizeInBytes;
 @end
 
 
@@ -1195,6 +1196,7 @@ extern void ns_set_alpha (void *img, int x, int y, unsigned char a);
 
 extern int ns_display_pixel_height (struct ns_display_info *);
 extern int ns_display_pixel_width (struct ns_display_info *);
+extern size_t ns_image_size_in_bytes (void *img);
 
 /* This in nsterm.m */
 extern float ns_antialias_threshold;
diff --git a/src/nsterm.m b/src/nsterm.m
index 7972fa4dabb..2a117a07801 100644
--- a/src/nsterm.m
+++ b/src/nsterm.m
@@ -5541,9 +5541,8 @@ ns_term_init (Lisp_Object display_name)
     /* There are 752 colors defined in rgb.txt.  */
     if ( cl == nil || [[cl allKeys] count] < 752)
       {
-        Lisp_Object color_file, color_map, color;
+        Lisp_Object color_file, color_map, color, name;
         unsigned long c;
-        char *name;
 
         color_file = Fexpand_file_name (build_string ("rgb.txt"),
                          Fsymbol_value (intern ("data-directory")));
@@ -5556,14 +5555,14 @@ ns_term_init (Lisp_Object display_name)
         for ( ; CONSP (color_map); color_map = XCDR (color_map))
           {
             color = XCAR (color_map);
-            name = SSDATA (XCAR (color));
+            name = XCAR (color);
             c = XFIXNUM (XCDR (color));
             [cl setColor:
                   [NSColor colorForEmacsRed: RED_FROM_ULONG (c) / 255.0
                                       green: GREEN_FROM_ULONG (c) / 255.0
                                        blue: BLUE_FROM_ULONG (c) / 255.0
                                       alpha: 1.0]
-                  forKey: [NSString stringWithUTF8String: name]];
+                  forKey: [NSString stringWithLispString: name]];
           }
 
         /* FIXME: Report any errors writing the color file below.  */
@@ -7619,8 +7618,7 @@ not_in_argv (NSString *arg)
     [self registerForDraggedTypes: ns_drag_types];
 
   tem = f->name;
-  name = [NSString stringWithUTF8String:
-                   NILP (tem) ? "Emacs" : SSDATA (tem)];
+  name = NILP (tem) ? @"Emacs" : [NSString stringWithLispString:tem];
   [win setTitle: name];
 
   /* toolbar support */
diff --git a/src/nsxwidget.m b/src/nsxwidget.m
index dbd4cb29a62..915fd8b59ce 100644
--- a/src/nsxwidget.m
+++ b/src/nsxwidget.m
@@ -296,8 +296,6 @@ static NSString *xwScript;
 
 /* Xwidget webkit commands.  */
 
-static Lisp_Object build_string_with_nsstr (NSString *nsstr);
-
 bool
 nsxwidget_is_web_view (struct xwidget *xw)
 {
@@ -309,14 +307,14 @@ Lisp_Object
 nsxwidget_webkit_uri (struct xwidget *xw)
 {
   XwWebView *xwWebView = (XwWebView *) xw->xwWidget;
-  return build_string_with_nsstr (xwWebView.URL.absoluteString);
+  return [xwWebView.URL.absoluteString lispString];
 }
 
 Lisp_Object
 nsxwidget_webkit_title (struct xwidget *xw)
 {
   XwWebView *xwWebView = (XwWebView *) xw->xwWidget;
-  return build_string_with_nsstr (xwWebView.title);
+  return [xwWebView.title lispString];
 }
 
 /* @Note ATS - Need application transport security in 'Info.plist' or
@@ -350,15 +348,6 @@ nsxwidget_webkit_zoom (struct xwidget *xw, double zoom_change)
   /* TODO: setMagnification:centeredAtPoint.  */
 }
 
-/* Build lisp string */
-static Lisp_Object
-build_string_with_nsstr (NSString *nsstr)
-{
-  const char *utfstr = [nsstr UTF8String];
-  NSUInteger bytes = [nsstr lengthOfBytesUsingEncoding:NSUTF8StringEncoding];
-  return make_string (utfstr, bytes);
-}
-
 /* Recursively convert an objc native type JavaScript value to a Lisp
    value.  Mostly copied from GTK xwidget 'webkit_js_to_lisp'.  */
 static Lisp_Object
@@ -367,7 +356,7 @@ js_to_lisp (id value)
   if (value == nil || [value isKindOfClass:NSNull.class])
     return Qnil;
   else if ([value isKindOfClass:NSString.class])
-    return build_string_with_nsstr ((NSString *) value);
+    return [(NSString *) value lispString];
   else if ([value isKindOfClass:NSNumber.class])
     {
       NSNumber *nsnum = (NSNumber *) value;
@@ -407,7 +396,7 @@ js_to_lisp (id value)
         {
           NSString *prop_key = (NSString *) [keys objectAtIndex:i];
           id prop_value = [nsdict valueForKey:prop_key];
-          p->contents[i] = Fcons (build_string_with_nsstr (prop_key),
+          p->contents[i] = Fcons ([prop_key lispString],
                                   js_to_lisp (prop_value));
         }
       XSETVECTOR (obj, p);
diff --git a/src/pdumper.c b/src/pdumper.c
index 0096a4d45a3..f31e5888970 100644
--- a/src/pdumper.c
+++ b/src/pdumper.c
@@ -2692,7 +2692,7 @@ dump_hash_table (struct dump_context *ctx,
 static dump_off
 dump_buffer (struct dump_context *ctx, const struct buffer *in_buffer)
 {
-#if CHECK_STRUCTS && !defined HASH_buffer_EE36B4292E
+#if CHECK_STRUCTS && !defined HASH_buffer_99D642C1CB
 # error "buffer changed. See CHECK_STRUCTS comment in config.h."
 #endif
   struct buffer munged_buffer = *in_buffer;
diff --git a/src/print.c b/src/print.c
index 008bf5e6391..ec271d914cc 100644
--- a/src/print.c
+++ b/src/print.c
@@ -562,7 +562,7 @@ temp_output_buffer_setup (const char *bufname)
 
   record_unwind_current_buffer ();
 
-  Fset_buffer (Fget_buffer_create (build_string (bufname)));
+  Fset_buffer (Fget_buffer_create (build_string (bufname), Qnil));
 
   Fkill_all_local_variables ();
   delete_all_overlays (current_buffer);
diff --git a/src/process.c b/src/process.c
index b2d94d8f8a8..c306e6bbdd3 100644
--- a/src/process.c
+++ b/src/process.c
@@ -1731,7 +1731,7 @@ usage: (make-process &rest ARGS)  */)
 
   buffer = Fplist_get (contact, QCbuffer);
   if (!NILP (buffer))
-    buffer = Fget_buffer_create (buffer);
+    buffer = Fget_buffer_create (buffer, Qnil);
 
   /* Make sure that the child will be able to chdir to the current
      buffer's current directory, or its unhandled equivalent.  We
@@ -1768,7 +1768,7 @@ usage: (make-process &rest ARGS)  */)
                           QCname,
                           concat2 (name, build_string (" stderr")),
                           QCbuffer,
-                          Fget_buffer_create (xstderr),
+                          Fget_buffer_create (xstderr, Qnil),
                           QCnoquery,
                           query_on_exit ? Qnil : Qt);
     }
@@ -2047,13 +2047,12 @@ create_process (Lisp_Object process, char **new_argv, Lisp_Object current_dir)
 {
   struct Lisp_Process *p = XPROCESS (process);
   int inchannel, outchannel;
-  pid_t pid;
+  pid_t pid = -1;
   int vfork_errno;
   int forkin, forkout, forkerr = -1;
   bool pty_flag = 0;
   char pty_name[PTY_NAME_SIZE];
   Lisp_Object lisp_pty_name = Qnil;
-  sigset_t oldset;
 
   inchannel = outchannel = -1;
 
@@ -2124,152 +2123,28 @@ create_process (Lisp_Object process, char **new_argv, Lisp_Object current_dir)
   if (!EQ (p->command, Qt))
     add_process_read_fd (inchannel);
 
+  ptrdiff_t count = SPECPDL_INDEX ();
+
   /* This may signal an error.  */
   setup_process_coding_systems (process);
-
-  block_input ();
-  block_child_signal (&oldset);
-
-#ifndef WINDOWSNT
-  /* vfork, and prevent local vars from being clobbered by the vfork.  */
-  Lisp_Object volatile current_dir_volatile = current_dir;
-  Lisp_Object volatile lisp_pty_name_volatile = lisp_pty_name;
-  char **volatile new_argv_volatile = new_argv;
-  int volatile forkin_volatile = forkin;
-  int volatile forkout_volatile = forkout;
-  int volatile forkerr_volatile = forkerr;
-  struct Lisp_Process *p_volatile = p;
-
-#ifdef DARWIN_OS
-  /* Darwin doesn't let us run setsid after a vfork, so use fork when
-     necessary.  Also, reset SIGCHLD handling after a vfork, as
-     apparently macOS can mistakenly deliver SIGCHLD to the child.  */
-  if (pty_flag)
-    pid = fork ();
-  else
-    {
-      pid = vfork ();
-      if (pid == 0)
-        signal (SIGCHLD, SIG_DFL);
-    }
-#else
-  pid = vfork ();
-#endif
-
-  current_dir = current_dir_volatile;
-  lisp_pty_name = lisp_pty_name_volatile;
-  new_argv = new_argv_volatile;
-  forkin = forkin_volatile;
-  forkout = forkout_volatile;
-  forkerr = forkerr_volatile;
-  p = p_volatile;
+  char **env = make_environment_block (current_dir);
 
   pty_flag = p->pty_flag;
+  eassert (pty_flag == ! NILP (lisp_pty_name));
 
-  if (pid == 0)
-#endif /* not WINDOWSNT */
-    {
-      /* Make the pty be the controlling terminal of the process.  */
-#ifdef HAVE_PTYS
-      dissociate_controlling_tty ();
-
-      /* Make the pty's terminal the controlling terminal.  */
-      if (pty_flag && forkin >= 0)
-        {
-#ifdef TIOCSCTTY
-          /* We ignore the return value
-             because faith@cs.unc.edu says that is necessary on Linux.  */
-          ioctl (forkin, TIOCSCTTY, 0);
-#endif
-        }
-#if defined (LDISC1)
-      if (pty_flag && forkin >= 0)
-        {
-          struct termios t;
-          tcgetattr (forkin, &t);
-          t.c_lflag = LDISC1;
-          if (tcsetattr (forkin, TCSANOW, &t) < 0)
-            emacs_perror ("create_process/tcsetattr LDISC1");
-        }
-#else
-#if defined (NTTYDISC) && defined (TIOCSETD)
-      if (pty_flag && forkin >= 0)
-        {
-          /* Use new line discipline.  */
-          int ldisc = NTTYDISC;
-          ioctl (forkin, TIOCSETD, &ldisc);
-        }
-#endif
-#endif
+  vfork_errno
+    = emacs_spawn (&pid, forkin, forkout, forkerr, new_argv, env,
+                   SSDATA (current_dir),
+                   pty_flag ? SSDATA (lisp_pty_name) : NULL);
 
-#if !defined (DONT_REOPEN_PTY)
-/*** There is a suggestion that this ought to be a
-     conditional on TIOCSPGRP, or !defined TIOCSCTTY.
-     Trying the latter gave the wrong results on Debian GNU/Linux 1.1;
-     that system does seem to need this code, even though
-     both TIOCSCTTY is defined.  */
-        /* Now close the pty (if we had it open) and reopen it.
-           This makes the pty the controlling terminal of the subprocess.  */
-      if (pty_flag)
-        {
+  eassert ((vfork_errno == 0) == (0 < pid));
 
-          /* I wonder if emacs_close (emacs_open (SSDATA (lisp_pty_name), ...))
-             would work?  */
-          if (forkin >= 0)
-            emacs_close (forkin);
-          forkout = forkin = emacs_open (SSDATA (lisp_pty_name), O_RDWR, 0);
-
-          if (forkin < 0)
-            {
-              emacs_perror (SSDATA (lisp_pty_name));
-              _exit (EXIT_CANCELED);
-            }
-
-        }
-#endif /* not DONT_REOPEN_PTY */
-
-#ifdef SETUP_SLAVE_PTY
-      if (pty_flag)
-        {
-          SETUP_SLAVE_PTY;
-        }
-#endif /* SETUP_SLAVE_PTY */
-#endif /* HAVE_PTYS */
-
-      signal (SIGINT, SIG_DFL);
-      signal (SIGQUIT, SIG_DFL);
-#ifdef SIGPROF
-      signal (SIGPROF, SIG_DFL);
-#endif
-
-      /* Emacs ignores SIGPIPE, but the child should not.  */
-      signal (SIGPIPE, SIG_DFL);
-
-      /* Stop blocking SIGCHLD in the child.  */
-      unblock_child_signal (&oldset);
-
-      if (pty_flag)
-        child_setup_tty (forkout);
-
-      if (forkerr < 0)
-        forkerr = forkout;
-#ifdef WINDOWSNT
-      pid = child_setup (forkin, forkout, forkerr, new_argv, 1, current_dir);
-#else  /* not WINDOWSNT */
-      child_setup (forkin, forkout, forkerr, new_argv, 1, current_dir);
-#endif /* not WINDOWSNT */
-    }
-
-  /* Back in the parent process.  */
-
-  vfork_errno = errno;
   p->pid = pid;
   if (pid >= 0)
     p->alive = 1;
 
-  /* Stop blocking in the parent.  */
-  unblock_child_signal (&oldset);
-  unblock_input ();
+  /* Environment block no longer needed.  */
+  unbind_to (count, Qnil);
 
   if (pid < 0)
     report_file_errno (CHILD_SETUP_ERROR_DESC, Qnil, vfork_errno);
@@ -2443,7 +2318,7 @@ usage:  (make-pipe-process &rest ARGS)  */)
   buffer = Fplist_get (contact, QCbuffer);
   if (NILP (buffer))
     buffer = name;
-  buffer = Fget_buffer_create (buffer);
+  buffer = Fget_buffer_create (buffer, Qnil);
   pset_buffer (p, buffer);
 
   pset_childp (p, contact);
@@ -3173,7 +3048,7 @@ usage:  (make-serial-process &rest ARGS)  */)
   buffer = Fplist_get (contact, QCbuffer);
   if (NILP (buffer))
     buffer = name;
-  buffer = Fget_buffer_create (buffer);
+  buffer = Fget_buffer_create (buffer, Qnil);
   pset_buffer (p, buffer);
 
   pset_childp (p, contact);
@@ -4188,7 +4063,7 @@ usage: (make-network-process &rest ARGS)  */)
  open_socket:
 
   if (!NILP (buffer))
-    buffer = Fget_buffer_create (buffer);
+    buffer = Fget_buffer_create (buffer, Qnil);
 
   /* Unwind bind_polling_period.  */
   unbind_to (count, Qnil);
@@ -4637,6 +4512,12 @@ network_lookup_address_info_1 (Lisp_Object host, const char *service,
   if (STRING_MULTIBYTE (host) && SBYTES (host) != SCHARS (host))
     error ("Non-ASCII hostname %s detected, please use puny-encode-domain",
            SSDATA (host));
+
+#ifdef WINDOWSNT
+  /* Ensure socket support is loaded if available.  */
+  init_winsock (TRUE);
+#endif
+
   ret = getaddrinfo (SSDATA (host), service, hints, res);
   if (ret)
     {
@@ -4961,7 +4842,7 @@ server_accept_connection (Lisp_Object server, int channel)
       if (!NILP (buffer))
         {
           args[1] = buffer;
-          buffer = Fget_buffer_create (Fformat (nargs, args));
+          buffer = Fget_buffer_create (Fformat (nargs, args), Qnil);
         }
     }
 
diff --git a/src/sysdep.c b/src/sysdep.c
index 29c88f5308e..eeb9d184940 100644
--- a/src/sysdep.c
+++ b/src/sysdep.c
@@ -314,33 +314,21 @@ get_current_dir_name_or_unreachable (void)
       && emacs_fstatat (AT_FDCWD, ".", &dotstat, 0) == 0
       && dotstat.st_ino == pwdstat.st_ino
       && dotstat.st_dev == pwdstat.st_dev)
-    {
-      char *buf = malloc (pwdlen + 1);
-      if (!buf)
-        return NULL;
-      return memcpy (buf, pwd, pwdlen + 1);
-    }
+    return strdup (pwd);
   else
     {
       ptrdiff_t buf_size = min (bufsize_max, 1024);
-      char *buf = malloc (buf_size);
-      if (!buf)
-        return NULL;
       for (;;)
         {
+          char *buf = malloc (buf_size);
+          if (!buf)
+            return NULL;
           if (getcwd (buf, buf_size) == buf)
             return buf;
-          int getcwd_errno = errno;
-          if (getcwd_errno != ERANGE || buf_size == bufsize_max)
-            {
-              free (buf);
-              errno = getcwd_errno;
-              return NULL;
-            }
+          free (buf);
+          if (errno != ERANGE || buf_size == bufsize_max)
+            return NULL;
           buf_size = buf_size <= bufsize_max / 2 ? 2 * buf_size : bufsize_max;
-          buf = realloc (buf, buf_size);
-          if (!buf)
-            return NULL;
         }
     }
 }
diff --git a/src/w32.h b/src/w32.h
index 1afb8ad0873..e23ea6a675d 100644
--- a/src/w32.h
+++ b/src/w32.h
@@ -216,7 +216,7 @@ extern int sys_rename_replace (char const *, char const *, BOOL);
 extern int pipe2 (int *, int);
 extern void register_aux_fd (int);
 
-extern void set_process_dir (char *);
+extern void set_process_dir (const char *);
 extern int sys_spawnve (int, char *, char **, char **);
 extern void register_child (pid_t, int);
 
diff --git a/src/w32fns.c b/src/w32fns.c
index a840f0e1227..36bee0676ba 100644
--- a/src/w32fns.c
+++ b/src/w32fns.c
@@ -7372,7 +7372,7 @@ DEFUN ("x-show-tip", Fx_show_tip, Sx_show_tip, 1, 6, 0,
 
   tip_f = XFRAME (tip_frame);
   window = FRAME_ROOT_WINDOW (tip_f);
-  tip_buf = Fget_buffer_create (tip);
+  tip_buf = Fget_buffer_create (tip, Qnil);
   /* We will mark the tip window a "pseudo-window" below, and such
      windows cannot have display margins.  */
   bset_left_margin_cols (XBUFFER (tip_buf), make_fixnum (0));
diff --git a/src/w32gui.h b/src/w32gui.h
index fc8131130fb..f6cfa9fb87e 100644
--- a/src/w32gui.h
+++ b/src/w32gui.h
@@ -46,7 +46,7 @@ extern int w32_load_image (struct frame *f, struct image *img,
                            Lisp_Object spec_file, Lisp_Object spec_data);
 extern bool w32_can_use_native_image_api (Lisp_Object);
 extern void w32_gdiplus_shutdown (void);
-extern size_t w32_image_size (struct image *);
+extern size_t w32_image_size (Emacs_Pixmap);
 
 #define FACE_DEFAULT (~0)
 
diff --git a/src/w32proc.c b/src/w32proc.c
index 0cf82013065..66cdf7de461 100644
--- a/src/w32proc.c
+++ b/src/w32proc.c
@@ -3019,9 +3019,9 @@ reset_standard_handles (int in, int out, int err, HANDLE handles[3])
 }
 
 void
-set_process_dir (char * dir)
+set_process_dir (const char * dir)
 {
-  process_dir = dir;
+  process_dir = (char *) dir;
 }
 
 /* To avoid problems with winsock implementations that work over dial-up
diff --git a/src/w32term.c b/src/w32term.c
index a038e4593f4..989b056ff2e 100644
--- a/src/w32term.c
+++ b/src/w32term.c
@@ -1992,12 +1992,12 @@ w32_draw_image_foreground (struct glyph_string *s)
 }
 
 size_t
-w32_image_size (struct image *img)
+w32_image_size (Emacs_Pixmap pixmap)
 {
   BITMAP bm_info;
   size_t rv = 0;
 
-  if (GetObject (img->pixmap, sizeof (BITMAP), &bm_info))
+  if (GetObject (pixmap, sizeof (BITMAP), &bm_info))
     rv = bm_info.bmWidth * bm_info.bmHeight * bm_info.bmBitsPixel / 8;
   return rv;
 }
diff --git a/src/window.c b/src/window.c
index bcc989b5a79..5db166e345e 100644
--- a/src/window.c
+++ b/src/window.c
@@ -617,11 +617,12 @@ equals the special symbol `mark-for-redisplay'.
 Run `buffer-list-update-hook' unless NORECORD is non-nil.  Note that
 applications and internal routines often select a window temporarily for
 various purposes; mostly, to simplify coding.  As a rule, such
-selections should be not recorded and therefore will not pollute
+selections should not be recorded and therefore will not pollute
 `buffer-list-update-hook'.  Selections that "really count" are those
 causing a visible change in the next redisplay of WINDOW's frame and
-should be always recorded.  So if you think of running a function each
-time a window gets selected put it on `buffer-list-update-hook'.
+should always be recorded.  So if you think of running a function each
+time a window gets selected, put it on `buffer-list-update-hook' or
+`window-selection-change-functions'.
 
 Also note that the main editor command loop sets the current buffer to
 the buffer of the selected window before each command.  */)
diff --git a/src/xdisp.c b/src/xdisp.c
index 5533c82d143..c28a5cf5188 100644
--- a/src/xdisp.c
+++ b/src/xdisp.c
@@ -10880,7 +10880,7 @@ message_dolog (const char *m, ptrdiff_t nbytes, bool nlflag, bool multibyte)
       /* Ensure the Messages buffer exists, and switch to it.
          If we created it, set the major-mode.  */
       bool newbuffer = NILP (Fget_buffer (Vmessages_buffer_name));
-      Fset_buffer (Fget_buffer_create (Vmessages_buffer_name));
+      Fset_buffer (Fget_buffer_create (Vmessages_buffer_name, Qnil));
       if (newbuffer
           && !NILP (Ffboundp (intern ("messages-buffer-mode"))))
         call0 (intern ("messages-buffer-mode"));
@@ -11366,7 +11366,7 @@ ensure_echo_area_buffers (void)
         static char const name_fmt[] = " *Echo Area %d*";
         char name[sizeof name_fmt + INT_STRLEN_BOUND (int)];
         AUTO_STRING_WITH_LEN (lname, name, sprintf (name, name_fmt, i));
-        echo_buffer[i] = Fget_buffer_create (lname);
+        echo_buffer[i] = Fget_buffer_create (lname, Qnil);
         bset_truncate_lines (XBUFFER (echo_buffer[i]), Qnil);
         /* to force word wrap in echo area -
            it was decided to postpone this*/
diff --git a/src/xfns.c b/src/xfns.c
index 46e4bd73a6b..abe293e903e 100644
--- a/src/xfns.c
+++ b/src/xfns.c
@@ -7041,7 +7041,7 @@ Text larger than the specified size is clipped.  */)
 
   tip_f = XFRAME (tip_frame);
   window = FRAME_ROOT_WINDOW (tip_f);
-  tip_buf = Fget_buffer_create (tip);
+  tip_buf = Fget_buffer_create (tip, Qnil);
   /* We will mark the tip window a "pseudo-window" below, and such
      windows cannot have display margins.  */
   bset_left_margin_cols (XBUFFER (tip_buf), make_fixnum (0));
diff --git a/src/xterm.c b/src/xterm.c
index 3de0d2e73c0..7f8728e47c4 100644
--- a/src/xterm.c
+++ b/src/xterm.c
@@ -8947,7 +8947,9 @@ handle_one_xevent (struct x_display_info *dpyinfo,
       if (!f
           && (f = any)
           && configureEvent.xconfigure.window == FRAME_X_WINDOW (f)
-          && FRAME_VISIBLE_P(f))
+          && (FRAME_VISIBLE_P(f)
+              || !(configureEvent.xconfigure.width <= 1
+                   && configureEvent.xconfigure.height <= 1)))
         {
           block_input ();
           if (FRAME_X_DOUBLE_BUFFERED_P (f))
@@ -8962,7 +8964,10 @@ handle_one_xevent (struct x_display_info *dpyinfo,
           f = 0;
         }
 #endif
-      if (f && FRAME_VISIBLE_P(f))
+      if (f
+          && (FRAME_VISIBLE_P(f)
+              || !(configureEvent.xconfigure.width <= 1
+                   && configureEvent.xconfigure.height <= 1)))
         {
 #ifdef USE_GTK
           /* For GTK+ don't call x_net_wm_state for the scroll bar
diff --git a/src/xwidget.c b/src/xwidget.c
index 893292cf5ae..44ca0424d50 100644
--- a/src/xwidget.c
+++ b/src/xwidget.c
@@ -100,7 +100,8 @@ Returns the newly constructed xwidget, or nil if construction fails.  */)
   Lisp_Object val;
   xw->type = type;
   xw->title = title;
-  xw->buffer = NILP (buffer) ? Fcurrent_buffer () : Fget_buffer_create (buffer);
+  xw->buffer = (NILP (buffer) ? Fcurrent_buffer ()
+                : Fget_buffer_create (buffer, Qnil));
   xw->height = XFIXNAT (height);
   xw->width = XFIXNAT (width);
   xw->kill_without_query = false;