Merge remote-tracking branch 'origin/master' into feature/package+vc

37 files changed, 2068 insertions, 1016 deletions

diff --git a/src/Makefile.in b/src/Makefile.in
index 7d15b7afd51..92a8790efdc 100644
--- a/src/Makefile.in
+++ b/src/Makefile.in
@@ -635,30 +635,23 @@ Emacs.pdmp: $(pdmp)
 endif
 
 ifeq ($(DUMPING),pdumper)
-$(pdmp): emacs$(EXEEXT)
+$(pdmp): emacs$(EXEEXT) $(lispsource)/loaddefs.el $(lispsource)/loaddefs.elc
         LC_ALL=C $(RUN_TEMACS) -batch $(BUILD_DETAILS) -l loadup --temacs=pdump \
                 --bin-dest $(BIN_DESTDIR) --eln-dest $(ELN_DESTDIR)
         cp -f $@ $(bootstrap_pdmp)
 endif
 
-## We run make-docfile twice because the command line may get too long
-## on some systems.  Unfortunately, no-one has any idea
-## exactly how long the maximum safe command line length is on all the
-## various systems that Emacs supports.
-##
 ## $(SOME_MACHINE_OBJECTS) comes before $(obj) because some files may
 ## or may not be included in $(obj), but they are always included in
 ## $(SOME_MACHINE_OBJECTS).  Since a file is processed when it is mentioned
 ## for the first time, this prevents any variation between configurations
 ## in the contents of the DOC file.
 ##
-$(etc)/DOC: $(libsrc)/make-docfile$(EXEEXT) $(doc_obj) $(lispsource)/loaddefs.el
+$(etc)/DOC: $(libsrc)/make-docfile$(EXEEXT) $(doc_obj)
         $(AM_V_GEN)$(MKDIR_P) $(etc)
         $(AM_V_at)rm -f $(etc)/DOC
         $(AM_V_at)$(libsrc)/make-docfile -d $(srcdir) \
           $(SOME_MACHINE_OBJECTS) $(doc_obj) > $(etc)/DOC
-        $(AM_V_at)$(libsrc)/make-docfile -a $(etc)/DOC -d $(lispsource) \
-          loaddefs.el
 
 $(libsrc)/make-docfile$(EXEEXT) $(libsrc)/make-fingerprint$(EXEEXT): \
   $(lib)/libgnu.a
@@ -888,13 +881,7 @@ elnlisp := $(addprefix ${lispsource}/,${elnlisp}) $(lisp:.elc=.eln)
         fi
 endif
 
-## VCSWITNESS points to the file that holds info about the current checkout.
-## We use it as a heuristic to decide when to rebuild loaddefs.el.
-## If empty it is ignored; the parent makefile can set it to some other value.
-VCSWITNESS =
-
-$(lispsource)/loaddefs.el: $(VCSWITNESS) | \
-                bootstrap-emacs$(EXEEXT) $(bootstrap_pdmp)
+$(lispsource)/loaddefs.el: | bootstrap-emacs$(EXEEXT) $(bootstrap_pdmp)
         $(MAKE) -C ../lisp autoloads EMACS="$(bootstrap_exe)"
 
 ## Dump an Emacs executable named bootstrap-emacs containing the
diff --git a/src/buffer.c b/src/buffer.c
index a07194aef72..e5601af5051 100644
--- a/src/buffer.c
+++ b/src/buffer.c
@@ -6431,12 +6431,15 @@ will run for `clone-indirect-buffer' calls as well.  */);
 
   DEFVAR_LISP ("long-line-threshold", Vlong_line_threshold,
     doc: /* Line length above which to use redisplay shortcuts.
+
 The value should be a positive integer or nil.
 If the value is an integer, shortcuts in the display code intended
 to speed up redisplay for long lines will automatically be enabled
 in buffers which contain one or more lines whose length is above
 this threshold.
-If nil, these display shortcuts will always remain disabled.  */);
+If nil, these display shortcuts will always remain disabled.
+
+There is no reason to change that value except for debugging purposes.  */);
   XSETFASTINT (Vlong_line_threshold, 10000);
 
   defsubr (&Sbuffer_live_p);
diff --git a/src/bytecode.c b/src/bytecode.c
index 2b1eccdc518..d75767bb0c5 100644
--- a/src/bytecode.c
+++ b/src/bytecode.c
@@ -1480,8 +1480,8 @@ exec_byte_code (Lisp_Object fun, ptrdiff_t args_template,
 
         CASE (Bnarrow_to_region):
           {
-            Lisp_Object v2 = POP, v1 = POP;
-            TOP = Fnarrow_to_region (TOP, v1, v2);
+            Lisp_Object v1 = POP;
+            TOP = Fnarrow_to_region (TOP, v1);
             NEXT;
           }
 
diff --git a/src/callint.c b/src/callint.c
index ffa3b231eb5..c974967459c 100644
--- a/src/callint.c
+++ b/src/callint.c
@@ -161,73 +161,33 @@ check_mark (bool for_region)
     xsignal0 (Qmark_inactive);
 }
 
-/* If the list of args INPUT was produced with an explicit call to
-   `list', look for elements that were computed with
-   (region-beginning) or (region-end), and put those expressions into
-   VALUES instead of the present values.
+/* If FUNCTION has an `interactive-args' spec, replace relevant
+   elements in VALUES with those forms instead.
 
    This function doesn't return a value because it modifies elements
    of VALUES to do its job.  */
 
 static void
-fix_command (Lisp_Object input, Lisp_Object function, Lisp_Object values)
+fix_command (Lisp_Object function, Lisp_Object values)
 {
-  /* FIXME: Instead of this ugly hack, we should provide a way for an
-     interactive spec to return an expression/function that will re-build the
-     args without user intervention.  */
-  if (CONSP (input))
+  /* Quick exit if there's no values to alter.  */
+  if (!CONSP (values))
+    return;
+
+  Lisp_Object reps = Fget (function, Qinteractive_args);
+
+  if (CONSP (reps))
     {
-      Lisp_Object car;
+      int i = 0;
+      Lisp_Object vals = values;
 
-      car = XCAR (input);
-      /* Skip through certain special forms.  */
-      while (EQ (car, Qlet) || EQ (car, Qletx)
-             || EQ (car, Qsave_excursion)
-             || EQ (car, Qprogn))
+      while (!NILP (vals))
         {
-          while (CONSP (XCDR (input)))
-            input = XCDR (input);
-          input = XCAR (input);
-          if (!CONSP (input))
-            break;
-          car = XCAR (input);
-        }
-      if (EQ (car, Qlist))
-        {
-          Lisp_Object intail, valtail;
-          for (intail = Fcdr (input), valtail = values;
-               CONSP (valtail);
-               intail = Fcdr (intail), valtail = XCDR (valtail))
-            {
-              Lisp_Object elt;
-              elt = Fcar (intail);
-              if (CONSP (elt))
-                {
-                  Lisp_Object presflag, carelt;
-                  carelt = XCAR (elt);
-                  /* If it is (if X Y), look at Y.  */
-                  if (EQ (carelt, Qif)
-                      && NILP (Fnthcdr (make_fixnum (3), elt)))
-                    elt = Fnth (make_fixnum (2), elt);
-                  /* If it is (when ... Y), look at Y.  */
-                  else if (EQ (carelt, Qwhen))
-                    {
-                      while (CONSP (XCDR (elt)))
-                        elt = XCDR (elt);
-                      elt = Fcar (elt);
-                    }
-
-                  /* If the function call we're looking at
-                     is a special preserved one, copy the
-                     whole expression for this argument.  */
-                  if (CONSP (elt))
-                    {
-                      presflag = Fmemq (Fcar (elt), preserved_fns);
-                      if (!NILP (presflag))
-                        Fsetcar (valtail, Fcar (intail));
-                    }
-                }
-            }
+          Lisp_Object rep = Fassq (make_fixnum (i), reps);
+          if (!NILP (rep))
+            Fsetcar (vals, XCDR (rep));
+          vals = XCDR (vals);
+          ++i;
         }
     }
 
@@ -235,31 +195,28 @@ fix_command (Lisp_Object input, Lisp_Object function, Lisp_Object values)
      optional, remove them from the list.  This makes navigating the
      history less confusing, since it doesn't contain a lot of
      parameters that aren't used.  */
-  if (CONSP (values))
+  Lisp_Object arity = Ffunc_arity (function);
+  /* We don't want to do this simplification if we have an &rest
+     function, because (cl-defun foo (a &optional (b 'zot)) ..)
+     etc.  */
+  if (FIXNUMP (XCAR (arity)) && FIXNUMP (XCDR (arity)))
     {
-      Lisp_Object arity = Ffunc_arity (function);
-      /* We don't want to do this simplification if we have an &rest
-         function, because (cl-defun foo (a &optional (b 'zot)) ..)
-         etc.  */
-      if (FIXNUMP (XCAR (arity)) && FIXNUMP (XCDR (arity)))
+      Lisp_Object final = Qnil;
+      ptrdiff_t final_i = 0, i = 0;
+      for (Lisp_Object tail = values;
+           CONSP (tail);
+           tail = XCDR (tail), ++i)
         {
-          Lisp_Object final = Qnil;
-          ptrdiff_t final_i = 0, i = 0;
-          for (Lisp_Object tail = values;
-               CONSP (tail);
-               tail = XCDR (tail), ++i)
+          if (!NILP (XCAR (tail)))
             {
-              if (!NILP (XCAR (tail)))
-                {
-                  final = tail;
-                  final_i = i;
-                }
+              final = tail;
+              final_i = i;
             }
-
-          /* Chop the trailing optional values.  */
-          if (final_i > 0 && final_i >= XFIXNUM (XCAR (arity)) - 1)
-            XSETCDR (final,  Qnil);
         }
+
+      /* Chop the trailing optional values.  */
+      if (final_i > 0 && final_i >= XFIXNUM (XCAR (arity)) - 1)
+        XSETCDR (final,  Qnil);
     }
 }
 
@@ -360,7 +317,6 @@ invoke it (via an `interactive' spec that contains, for instance, an
     {
       Lisp_Object funval = Findirect_function (function, Qt);
       uintmax_t events = num_input_events;
-      Lisp_Object input = specs;
       /* Compute the arg values using the user's expression.  */
       specs = Feval (specs,
                      CONSP (funval) && EQ (Qclosure, XCAR (funval))
@@ -371,7 +327,7 @@ invoke it (via an `interactive' spec that contains, for instance, an
              Make a copy of the list of values, for the command history,
              and turn them into things we can eval.  */
           Lisp_Object values = quotify_args (Fcopy_sequence (specs));
-          fix_command (input, function, values);
+          fix_command (function, values);
           call4 (intern ("add-to-history"), intern ("command-history"),
                  Fcons (function, values), Qnil, Qt);
         }
@@ -950,4 +906,6 @@ use `event-start', `event-end', and `event-click-count'.  */);
   defsubr (&Scall_interactively);
   defsubr (&Sfuncall_interactively);
   defsubr (&Sprefix_numeric_value);
+
+  DEFSYM (Qinteractive_args, "interactive-args");
 }
diff --git a/src/callproc.c b/src/callproc.c
index dd162f36a6c..e8e4c48b5be 100644
--- a/src/callproc.c
+++ b/src/callproc.c
@@ -650,7 +650,7 @@ call_process (ptrdiff_t nargs, Lisp_Object *args, int filefd,
 
   child_errno
     = emacs_spawn (&pid, filefd, fd_output, fd_error, new_argv, env,
-                   SSDATA (current_dir), NULL, &oldset);
+                   SSDATA (current_dir), NULL, false, false, &oldset);
   eassert ((child_errno == 0) == (0 < pid));
 
   if (pid > 0)
@@ -1412,14 +1412,15 @@ emacs_posix_spawn_init_attributes (posix_spawnattr_t *attributes,
 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, const sigset_t *oldset)
+             const char *pty_name, bool pty_in, bool pty_out,
+             const sigset_t *oldset)
 {
 #if USABLE_POSIX_SPAWN
   /* Prefer the simpler `posix_spawn' if available.  `posix_spawn'
      doesn't yet support setting up pseudoterminals, so we fall back
      to `vfork' if we're supposed to use a pseudoterminal.  */
 
-  bool use_posix_spawn = pty == NULL;
+  bool use_posix_spawn = pty_name == NULL;
 
   posix_spawn_file_actions_t actions;
   posix_spawnattr_t attributes;
@@ -1473,7 +1474,9 @@ emacs_spawn (pid_t *newpid, int std_in, int std_out, int std_err,
   /* 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;
+  const char *volatile ptyname_volatile = pty_name;
+  bool volatile ptyin_volatile = pty_in;
+  bool volatile ptyout_volatile = pty_out;
   char **volatile argv_volatile = argv;
   int volatile stdin_volatile = std_in;
   int volatile stdout_volatile = std_out;
@@ -1485,7 +1488,7 @@ emacs_spawn (pid_t *newpid, int std_in, int std_out, int std_err,
   /* 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)
+  if (pty_in || pty_out)
     pid = fork ();
   else
     pid = VFORK ();
@@ -1495,7 +1498,9 @@ emacs_spawn (pid_t *newpid, int std_in, int std_out, int std_err,
 
   newpid = newpid_volatile;
   cwd = cwd_volatile;
-  pty = pty_volatile;
+  pty_name = ptyname_volatile;
+  pty_in = ptyin_volatile;
+  pty_out = ptyout_volatile;
   argv = argv_volatile;
   std_in = stdin_volatile;
   std_out = stdout_volatile;
@@ -1506,13 +1511,12 @@ emacs_spawn (pid_t *newpid, int std_in, int std_out, int std_err,
   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)
+      if (pty_in && std_in >= 0)
         {
 #ifdef TIOCSCTTY
           /* We ignore the return value
@@ -1521,7 +1525,7 @@ emacs_spawn (pid_t *newpid, int std_in, int std_out, int std_err,
 #endif
         }
 #if defined (LDISC1)
-      if (pty_flag && std_in >= 0)
+      if (pty_in && std_in >= 0)
         {
           struct termios t;
           tcgetattr (std_in, &t);
@@ -1531,7 +1535,7 @@ emacs_spawn (pid_t *newpid, int std_in, int std_out, int std_err,
         }
 #else
 #if defined (NTTYDISC) && defined (TIOCSETD)
-      if (pty_flag && std_in >= 0)
+      if (pty_in && std_in >= 0)
         {
           /* Use new line discipline.  */
           int ldisc = NTTYDISC;
@@ -1548,18 +1552,21 @@ emacs_spawn (pid_t *newpid, int std_in, int std_out, int std_err,
      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)
+      if (pty_name)
         {
 
           /* I wonder if emacs_close (emacs_open (pty, ...))
              would work?  */
-          if (std_in >= 0)
+          if (pty_in && std_in >= 0)
             emacs_close (std_in);
-          std_out = std_in = emacs_open_noquit (pty, O_RDWR, 0);
-
+          int ptyfd = emacs_open_noquit (pty_name, O_RDWR, 0);
+          if (pty_in)
+            std_in = ptyfd;
+          if (pty_out)
+            std_out = ptyfd;
           if (std_in < 0)
             {
-              emacs_perror (pty);
+              emacs_perror (pty_name);
               _exit (EXIT_CANCELED);
             }
 
@@ -1599,7 +1606,7 @@ emacs_spawn (pid_t *newpid, int std_in, int std_out, int std_err,
       /* Stop blocking SIGCHLD in the child.  */
       unblock_child_signal (oldset);
 
-      if (pty_flag)
+      if (pty_out)
         child_setup_tty (std_out);
 #endif
 
diff --git a/src/composite.c b/src/composite.c
index 0f90b92a785..22422cca090 100644
--- a/src/composite.c
+++ b/src/composite.c
@@ -24,6 +24,8 @@ along with GNU Emacs.  If not, see <https://www.gnu.org/licenses/>.  */
 
 #include <config.h>
 
+#include <stdlib.h>             /* for qsort */
+
 #include "lisp.h"
 #include "character.h"
 #include "composite.h"
@@ -1021,7 +1023,11 @@ composition_compute_stop_pos (struct composition_it *cmp_it, ptrdiff_t charpos,
           /* But we don't know where to stop the searching.  */
           endpos = NILP (string) ? BEGV - 1 : -1;
           /* Usually we don't reach ENDPOS because we stop searching
-             at an uncomposable character (NL, LRE, etc).  */
+             at an uncomposable character (NL, LRE, etc).  In buffers
+             with long lines, however, NL might be far away, so
+             pretend that the buffer is smaller.  */
+          if (current_buffer->long_line_optimizations_p)
+            endpos = get_closer_narrowed_begv (cmp_it->parent_it->w, charpos);
         }
     }
   cmp_it->id = -1;
@@ -1580,7 +1586,6 @@ find_automatic_composition (ptrdiff_t pos, ptrdiff_t limit, ptrdiff_t backlim,
   Lisp_Object window;
   struct window *w;
   bool need_adjustment = 0;
-  ptrdiff_t narrowed_begv;
 
   window = Fget_buffer_window (Fcurrent_buffer (), Qnil);
   if (NILP (window))
@@ -1597,11 +1602,14 @@ find_automatic_composition (ptrdiff_t pos, ptrdiff_t limit, ptrdiff_t backlim,
         }
       else
         head = backlim;
-      /* In buffers with very long lines, this function becomes very
-         slow.  Pretend that the buffer is narrowed to make it fast.  */
-      narrowed_begv = get_narrowed_begv (w, window_point (w));
-      if (narrowed_begv && pos > narrowed_begv)
-        head = narrowed_begv;
+      if (current_buffer->long_line_optimizations_p)
+        {
+          /* In buffers with very long lines, this function becomes very
+             slow.  Pretend that the buffer is narrowed to make it fast.  */
+          ptrdiff_t begv = get_closer_narrowed_begv (w, window_point (w));
+          if (pos > begv)
+            head = begv;
+        }
       tail = ZV;
       stop = GPT;
       cur.pos_byte = CHAR_TO_BYTE (cur.pos);
@@ -2048,6 +2056,54 @@ See `find-composition' for more details.  */)
   return Fcons (make_fixnum (start), Fcons (make_fixnum (end), tail));
 }
 
+static int
+compare_composition_rules (const void *r1, const void *r2)
+{
+  Lisp_Object vec1 = *(Lisp_Object *)r1, vec2 = *(Lisp_Object *)r2;
+
+  return XFIXNAT (AREF (vec2, 1)) - XFIXNAT (AREF (vec1, 1));
+}
+
+DEFUN ("composition-sort-rules", Fcomposition_sort_rules,
+       Scomposition_sort_rules, 1, 1, 0,
+       doc: /* Sort composition RULES by their LOOKBACK parameter.
+
+If RULES include just one rule, return RULES.
+Otherwise, return a new list of rules where all the rules are
+arranged in decreasing order of the LOOKBACK parameter of the
+rules (the second element of the rule's vector).  This is required
+when combining composition rules from different sources, because
+of the way buffer text is examined for matching one of the rules.  */)
+  (Lisp_Object rules)
+{
+  ptrdiff_t nrules;
+  USE_SAFE_ALLOCA;
+
+  CHECK_LIST (rules);
+  nrules = list_length (rules);
+  if (nrules > 1)
+    {
+      ptrdiff_t i;
+      Lisp_Object *sortvec;
+
+      SAFE_NALLOCA (sortvec, 1, nrules);
+      for (i = 0; i < nrules; i++)
+        {
+          Lisp_Object elt = XCAR (rules);
+          if (VECTORP (elt) && ASIZE (elt) == 3 && FIXNATP (AREF (elt, 1)))
+            sortvec[i] = elt;
+          else
+            error ("Invalid composition rule in RULES argument");
+          rules = XCDR (rules);
+        }
+      qsort (sortvec, nrules, sizeof (Lisp_Object), compare_composition_rules);
+      rules = Flist (nrules, sortvec);
+      SAFE_FREE ();
+    }
+
+  return rules;
+}
+
 
 void
 syms_of_composite (void)
@@ -2179,4 +2235,5 @@ This list is auto-generated, you should not need to modify it.  */);
   defsubr (&Sfind_composition_internal);
   defsubr (&Scomposition_get_gstring);
   defsubr (&Sclear_composition_cache);
+  defsubr (&Scomposition_sort_rules);
 }
diff --git a/src/dispextern.h b/src/dispextern.h
index 037e02ff58f..12ba927261f 100644
--- a/src/dispextern.h
+++ b/src/dispextern.h
@@ -2287,6 +2287,8 @@ struct composition_it
      reverse order, and thus the grapheme clusters must be rendered
      from the last to the first.  */
   bool reversed_p;
+  /* Parent iterator. */
+  struct it *parent_it;
 
   /** The following members contain information about the current
       grapheme cluster.  */
diff --git a/src/editfns.c b/src/editfns.c
index 79af27d24da..07f5c0bbef7 100644
--- a/src/editfns.c
+++ b/src/editfns.c
@@ -2660,9 +2660,11 @@ DEFUN ("widen", Fwiden, Swiden, 0, 0, "",
        doc: /* Remove restrictions (narrowing) from current buffer.
 This allows the buffer's full text to be seen and edited.
 
-When called from Lisp inside a body form in which `narrow-to-region'
-was called with an optional argument LOCK non-nil, this function does
-not produce any effect.  */)
+Note that, when the current buffer contains one or more lines whose
+length is above `long-line-threshold', Emacs may decide to leave, for
+performance reasons, the accessible portion of the buffer unchanged
+after this function is called from low-level hooks, such as
+`jit-lock-functions' or `post-command-hook'.  */)
   (void)
 {
   if (! NILP (Vrestrictions_locked))
@@ -2689,22 +2691,11 @@ unwind_locked_zv (Lisp_Object point_max)
   SET_BUF_ZV (current_buffer, XFIXNUM (point_max));
 }
 
-DEFUN ("narrow-to-region", Fnarrow_to_region, Snarrow_to_region, 2, 3, "r",
-       doc: /* Restrict editing in this buffer to the current region.
-The rest of the text becomes temporarily invisible and untouchable
-but is not deleted; if you save the buffer in a file, the invisible
-text is included in the file.  \\[widen] makes all visible again.
-See also `save-restriction'.
-
-When calling from Lisp, pass two arguments START and END:
-positions (integers or markers) bounding the text that should
-remain visible.
-
-When called from Lisp with the optional argument LOCK non-nil,
-calls to `widen', or to `narrow-to-region' with an optional
-argument LOCK nil, do not produce any effect until the end of
-the current body form.  */)
-  (Lisp_Object start, Lisp_Object end, Lisp_Object lock)
+/* Internal function for Fnarrow_to_region, meant to be used with a
+   third argument 'true', in which case it should be followed by "specbind
+   (Qrestrictions_locked, Qt)".  */
+Lisp_Object
+narrow_to_region_internal (Lisp_Object start, Lisp_Object end, bool lock)
 {
   EMACS_INT s = fix_position (start), e = fix_position (end);
 
@@ -2713,7 +2704,7 @@ the current body form.  */)
       EMACS_INT tem = s; s = e; e = tem;
     }
 
-  if (! NILP (lock))
+  if (lock)
     {
       if (!(BEGV <= s && s <= e && e <= ZV))
         args_out_of_range (start, end);
@@ -2727,8 +2718,6 @@ the current body form.  */)
 
       SET_BUF_BEGV (current_buffer, s);
       SET_BUF_ZV (current_buffer, e);
-
-      specbind (Qrestrictions_locked, Qt);
     }
   else
     {
@@ -2754,6 +2743,27 @@ the current body form.  */)
   return Qnil;
 }
 
+DEFUN ("narrow-to-region", Fnarrow_to_region, Snarrow_to_region, 2, 2, "r",
+       doc: /* Restrict editing in this buffer to the current region.
+The rest of the text becomes temporarily invisible and untouchable
+but is not deleted; if you save the buffer in a file, the invisible
+text is included in the file.  \\[widen] makes all visible again.
+See also `save-restriction'.
+
+When calling from Lisp, pass two arguments START and END:
+positions (integers or markers) bounding the text that should
+remain visible.
+
+Note that, when the current buffer contains one or more lines whose
+length is above `long-line-threshold', Emacs may decide to leave, for
+performance reasons, the accessible portion of the buffer unchanged
+after this function is called from low-level hooks, such as
+`jit-lock-functions' or `post-command-hook'.  */)
+  (Lisp_Object start, Lisp_Object end)
+{
+  return narrow_to_region_internal (start, end, false);
+}
+
 Lisp_Object
 save_restriction_save (void)
 {
diff --git a/src/eval.c b/src/eval.c
index 141d2546f08..56b42966623 100644
--- a/src/eval.c
+++ b/src/eval.c
@@ -57,6 +57,12 @@ Lisp_Object Vrun_hooks;
 /* FIXME: We should probably get rid of this!  */
 Lisp_Object Vsignaling_function;
 
+/* The handler structure which will catch errors in Lisp hooks called
+   from redisplay.  We do not use it for this; we compare it with the
+   handler which is about to be used in signal_or_quit, and if it
+   matches, cause a backtrace to be generated.  */
+static struct handler *redisplay_deep_handler;
+
 /* These would ordinarily be static, but they need to be visible to GDB.  */
 bool backtrace_p (union specbinding *) EXTERNALLY_VISIBLE;
 Lisp_Object *backtrace_args (union specbinding *) EXTERNALLY_VISIBLE;
@@ -246,6 +252,7 @@ init_eval (void)
   lisp_eval_depth = 0;
   /* This is less than the initial value of num_nonmacro_input_events.  */
   when_entered_debugger = -1;
+  redisplay_deep_handler = NULL;
 }
 
 /* Ensure that *M is at least A + B if possible, or is its maximum
@@ -333,7 +340,8 @@ call_debugger (Lisp_Object arg)
   /* Interrupting redisplay and resuming it later is not safe under
      all circumstances.  So, when the debugger returns, abort the
      interrupted redisplay by going back to the top-level.  */
-  if (debug_while_redisplaying)
+  if (debug_while_redisplaying
+      && !EQ (Vdebugger, Qdebug_early))
     Ftop_level ();
 
   return unbind_to (count, val);
@@ -593,16 +601,19 @@ The return value is BASE-VARIABLE.  */)
 
   if (SYMBOL_CONSTANT_P (new_alias))
     /* Making it an alias effectively changes its value.  */
-    error ("Cannot make a constant an alias");
+    error ("Cannot make a constant an alias: %s",
+           SDATA (SYMBOL_NAME (new_alias)));
 
   sym = XSYMBOL (new_alias);
 
   switch (sym->u.s.redirect)
     {
     case SYMBOL_FORWARDED:
-      error ("Cannot make an internal variable an alias");
+      error ("Cannot make a built-in variable an alias: %s",
+             SDATA (SYMBOL_NAME (new_alias)));
     case SYMBOL_LOCALIZED:
-      error ("Don't know how to make a localized variable an alias");
+      error ("Don't know how to make a buffer-local variable an alias: %s",
+             SDATA (SYMBOL_NAME (new_alias)));
     case SYMBOL_PLAINVAL:
     case SYMBOL_VARALIAS:
       break;
@@ -633,7 +644,8 @@ The return value is BASE-VARIABLE.  */)
     for (p = specpdl_ptr; p > specpdl; )
       if ((--p)->kind >= SPECPDL_LET
           && (EQ (new_alias, specpdl_symbol (p))))
-        error ("Don't know how to make a let-bound variable an alias");
+        error ("Don't know how to make a let-bound variable an alias: %s",
+               SDATA (SYMBOL_NAME (new_alias)));
   }
 
   if (sym->u.s.trapped_write == SYMBOL_TRAPPED_WRITE)
@@ -1552,12 +1564,16 @@ internal_condition_case_n (Lisp_Object (*bfun) (ptrdiff_t, Lisp_Object *),
                                                 ptrdiff_t nargs,
                                                 Lisp_Object *args))
 {
+  struct handler *old_deep = redisplay_deep_handler;
   struct handler *c = push_handler (handlers, CONDITION_CASE);
+  if (redisplaying_p)
+    redisplay_deep_handler = c;
   if (sys_setjmp (c->jmp))
     {
       Lisp_Object val = handlerlist->val;
       clobbered_eassert (handlerlist == c);
       handlerlist = handlerlist->next;
+      redisplay_deep_handler = old_deep;
       return hfun (val, nargs, args);
     }
   else
@@ -1565,6 +1581,7 @@ internal_condition_case_n (Lisp_Object (*bfun) (ptrdiff_t, Lisp_Object *),
       Lisp_Object val = bfun (nargs, args);
       eassert (handlerlist == c);
       handlerlist = c->next;
+      redisplay_deep_handler = old_deep;
       return val;
     }
 }
@@ -1697,6 +1714,11 @@ quit (void)
   return signal_or_quit (Qquit, Qnil, true);
 }
 
+/* Has an error in redisplay giving rise to a backtrace occurred as
+   yet in the current command?  This gets reset in the command
+   loop.  */
+bool backtrace_yet = false;
+
 /* Signal an error, or quit.  ERROR_SYMBOL and DATA are as with Fsignal.
    If KEYBOARD_QUIT, this is a quit; ERROR_SYMBOL should be
    Qquit and DATA should be Qnil, and this function may return.
@@ -1812,6 +1834,40 @@ signal_or_quit (Lisp_Object error_symbol, Lisp_Object data, bool keyboard_quit)
       unbind_to (count, Qnil);
     }
 
+  /* If an error is signalled during a Lisp hook in redisplay, write a
+     backtrace into the buffer *Redisplay-trace*.  */
+  if (!debugger_called && !NILP (error_symbol)
+      && backtrace_on_redisplay_error
+      && (NILP (clause) || h == redisplay_deep_handler)
+      && NILP (Vinhibit_debugger)
+      && !NILP (Ffboundp (Qdebug_early)))
+    {
+      max_ensure_room (&max_lisp_eval_depth, lisp_eval_depth, 100);
+      specpdl_ref count = SPECPDL_INDEX ();
+      ptrdiff_t counti = specpdl_ref_to_count (count);
+      AUTO_STRING (redisplay_trace, "*Redisplay_trace*");
+      Lisp_Object redisplay_trace_buffer;
+      AUTO_STRING (gap, "\n\n\n\n"); /* Separates things in *Redisplay-trace* */
+      Lisp_Object delayed_warning;
+      max_ensure_room (&max_specpdl_size, counti, 200);
+      redisplay_trace_buffer = Fget_buffer_create (redisplay_trace, Qnil);
+      current_buffer = XBUFFER (redisplay_trace_buffer);
+      if (!backtrace_yet) /* Are we on the first backtrace of the command?  */
+        Ferase_buffer ();
+      else
+        Finsert (1, &gap);
+      backtrace_yet = true;
+      specbind (Qstandard_output, redisplay_trace_buffer);
+      specbind (Qdebugger, Qdebug_early);
+      call_debugger (list2 (Qerror, Fcons (error_symbol, data)));
+      unbind_to (count, Qnil);
+      delayed_warning = make_string
+        ("Error in a redisplay Lisp hook.  See buffer *Redisplay_trace*", 61);
+
+      Vdelayed_warnings_list = Fcons (list2 (Qerror, delayed_warning),
+                                      Vdelayed_warnings_list);
+    }
+
   if (!NILP (clause))
     {
       Lisp_Object unwind_data
@@ -4274,6 +4330,11 @@ Does not apply if quit is handled by a `condition-case'.  */);
   DEFVAR_BOOL ("debug-on-next-call", debug_on_next_call,
                doc: /* Non-nil means enter debugger before next `eval', `apply' or `funcall'.  */);
 
+  DEFVAR_BOOL ("backtrace-on-redisplay-error", backtrace_on_redisplay_error,
+               doc: /* Non-nil means create a backtrace if a lisp error occurs in redisplay.
+The backtrace is written to buffer *Redisplay-trace*.  */);
+  backtrace_on_redisplay_error = false;
+
   DEFVAR_BOOL ("debugger-may-continue", debugger_may_continue,
                doc: /* Non-nil means debugger may continue execution.
 This is nil when the debugger is called under circumstances where it
diff --git a/src/frame.c b/src/frame.c
index a39e1c4944f..25d71e0769f 100644
--- a/src/frame.c
+++ b/src/frame.c
@@ -3916,9 +3916,10 @@ static const struct frame_parm_table frame_parms[] =
   {"z-group",                   SYMBOL_INDEX (Qz_group)},
   {"override-redirect",         SYMBOL_INDEX (Qoverride_redirect)},
   {"no-special-glyphs",         SYMBOL_INDEX (Qno_special_glyphs)},
-  {"alpha-background",          SYMBOL_INDEX (Qalpha_background)},
+  {"alpha-background",          SYMBOL_INDEX (Qalpha_background)},
+  {"use-frame-synchronization", SYMBOL_INDEX (Quse_frame_synchronization)},
 #ifdef HAVE_X_WINDOWS
-  {"shaded",                    SYMBOL_INDEX (Qshaded)},
+  {"shaded",                    SYMBOL_INDEX (Qshaded)},
 #endif
 #ifdef NS_IMPL_COCOA
   {"ns-appearance",             SYMBOL_INDEX (Qns_appearance)},
@@ -6195,6 +6196,7 @@ syms_of_frame (void)
   DEFSYM (Qtop_only, "top-only");
   DEFSYM (Qiconify_top_level, "iconify-top-level");
   DEFSYM (Qmake_invisible, "make-invisible");
+  DEFSYM (Quse_frame_synchronization, "use-frame-synchronization");
 
   {
     int i;
diff --git a/src/ftcrfont.c b/src/ftcrfont.c
index 6bb41110d5c..e089f9dea85 100644
--- a/src/ftcrfont.c
+++ b/src/ftcrfont.c
@@ -567,7 +567,7 @@ ftcrfont_draw (struct glyph_string *s,
       unblock_input ();
       return 0;
     }
-  BView_cr_dump_clipping (FRAME_HAIKU_VIEW (f), cr);
+  BView_cr_dump_clipping (FRAME_HAIKU_DRAWABLE (f), cr);
 #endif
 
   if (with_background)
@@ -677,7 +677,11 @@ ftcrhbfont_begin_hb_font (struct font *font, double *position_unit)
 
   ftcrfont_info->ft_size = ft_face->size;
   hb_font_t *hb_font = fthbfont_begin_hb_font (font, position_unit);
-  if (ftcrfont_info->bitmap_position_unit)
+  /* HarfBuzz 5 correctly scales bitmap-only fonts without position
+     unit adjustment.
+     (https://github.com/harfbuzz/harfbuzz/issues/489) */
+  if (!hb_version_atleast (5, 0, 0)
+      && ftcrfont_info->bitmap_position_unit)
     *position_unit = ftcrfont_info->bitmap_position_unit;
 
   return hb_font;
diff --git a/src/haiku_support.cc b/src/haiku_support.cc
index b7590f68a48..983928442a1 100644
--- a/src/haiku_support.cc
+++ b/src/haiku_support.cc
@@ -1512,6 +1512,8 @@ public:
 
   BMessage *wait_for_release_message;
   int64 grabbed_buttons;
+  BScreen screen;
+  bool use_frame_synchronization;
 
   EmacsView () : BView (BRect (0, 0, 0, 0), "Emacs",
                         B_FOLLOW_NONE, B_WILL_DRAW),
@@ -1524,7 +1526,8 @@ public:
                  cr_context (NULL),
 #endif
                  wait_for_release_message (NULL),
-                 grabbed_buttons (0)
+                 grabbed_buttons (0),
+                 use_frame_synchronization (false)
   {
 
   }
@@ -1547,6 +1550,16 @@ public:
   }
 
   void
+  SetFrameSynchronization (bool sync)
+  {
+    if (LockLooper ())
+      {
+        use_frame_synchronization = sync;
+        UnlockLooper ();
+      }
+  }
+
+  void
   MessageReceived (BMessage *msg)
   {
     uint32 buttons;
@@ -1722,14 +1735,14 @@ public:
   void
   FlipBuffers (void)
   {
+    EmacsWindow *w;
     if (!LockLooper ())
       gui_abort ("Failed to lock looper during buffer flip");
     if (!offscreen_draw_view)
       gui_abort ("Failed to lock offscreen view during buffer flip");
 
     offscreen_draw_view->Sync ();
-
-    EmacsWindow *w = (EmacsWindow *) Window ();
+    w = (EmacsWindow *) Window ();
     w->shown_flag = 0;
 
     if (copy_bitmap &&
@@ -1750,6 +1763,11 @@ public:
     if (copy_bitmap->InitCheck () != B_OK)
       gui_abort ("Failed to init copy bitmap during buffer flip");
 
+    /* Wait for VBLANK.  If responding to the invalidation or buffer
+       flipping takes longer than the blanking period, we lose.  */
+    if (use_frame_synchronization)
+      screen.WaitForRetrace ();
+
     Invalidate (&invalid_region);
     invalid_region.MakeEmpty ();
     UnlockLooper ();
@@ -5474,3 +5492,12 @@ be_clear_grab_view (void)
       grab_view_locker.Unlock ();
     }
 }
+
+void
+be_set_use_frame_synchronization (void *view, bool sync)
+{
+  EmacsView *vw;
+
+  vw = (EmacsView *) view;
+  vw->SetFrameSynchronization (sync);
+}
diff --git a/src/haiku_support.h b/src/haiku_support.h
index 76fe071f2c9..ca1808556a4 100644
--- a/src/haiku_support.h
+++ b/src/haiku_support.h
@@ -728,6 +728,7 @@ extern void be_lock_window (void *);
 extern void be_unlock_window (void *);
 extern bool be_get_explicit_workarea (int *, int *, int *, int *);
 extern void be_clear_grab_view (void);
+extern void be_set_use_frame_synchronization (void *, bool);
 #ifdef __cplusplus
 }
 
diff --git a/src/haikufns.c b/src/haikufns.c
index f3667ac2f9d..aaa4e866228 100644
--- a/src/haikufns.c
+++ b/src/haikufns.c
@@ -949,6 +949,10 @@ haiku_create_frame (Lisp_Object parms)
           || !FRAME_LIVE_P (XFRAME (KVAR (kb, Vdefault_minibuffer_frame)))))
     kset_default_minibuffer_frame (kb, frame);
 
+  /* Set whether or not frame synchronization is enabled.  */
+  gui_default_parameter (f, parms, Quse_frame_synchronization, Qt,
+                         NULL, NULL, RES_TYPE_BOOLEAN);
+
   gui_default_parameter (f, parms, Qz_group, Qnil,
                          NULL, NULL, RES_TYPE_SYMBOL);
 
@@ -1501,9 +1505,9 @@ haiku_set_background_color (struct frame *f, Lisp_Object arg, Lisp_Object oldval
 
   if (FRAME_HAIKU_VIEW (f))
     {
-      BView_draw_lock (FRAME_HAIKU_VIEW (f), false, 0, 0, 0, 0);
-      BView_SetViewColor (FRAME_HAIKU_VIEW (f), background);
-      BView_draw_unlock (FRAME_HAIKU_VIEW (f));
+     BView_draw_lock (FRAME_HAIKU_DRAWABLE (f), false, 0, 0, 0, 0);
+      BView_SetViewColor (FRAME_HAIKU_DRAWABLE (f), background);
+      BView_draw_unlock (FRAME_HAIKU_DRAWABLE (f));
 
       FRAME_OUTPUT_DATA (f)->cursor_fg = background;
       update_face_from_frame_parameter (f, Qbackground_color, arg);
@@ -2115,6 +2119,13 @@ haiku_set_mouse_color (struct frame *f, Lisp_Object arg, Lisp_Object oldval)
   update_face_from_frame_parameter (f, Qmouse_color, arg);
 }
 
+static void
+haiku_set_use_frame_synchronization (struct frame *f, Lisp_Object arg,
+                                     Lisp_Object oldval)
+{
+  be_set_use_frame_synchronization (FRAME_HAIKU_VIEW (f), !NILP (arg));
+}
+
 
 
 DEFUN ("haiku-set-mouse-absolute-pixel-position",
@@ -3128,6 +3139,7 @@ frame_parm_handler haiku_frame_parm_handlers[] =
     haiku_set_override_redirect,
     gui_set_no_special_glyphs,
     gui_set_alpha_background,
+    haiku_set_use_frame_synchronization,
   };
 
 void
diff --git a/src/haikuterm.c b/src/haikuterm.c
index f2bee1263d3..c2d4e34ba25 100644
--- a/src/haikuterm.c
+++ b/src/haikuterm.c
@@ -163,15 +163,15 @@ haiku_clip_to_string (struct glyph_string *s)
       /* If n[FOO].width is 0, it means to not draw at all, so set the
          clipping to some impossible value.  */
       if (r[0].width <= 0)
-        BView_ClipToRect (FRAME_HAIKU_VIEW (s->f),
+        BView_ClipToRect (FRAME_HAIKU_DRAWABLE (s->f),
                           FRAME_PIXEL_WIDTH (s->f),
                           FRAME_PIXEL_HEIGHT (s->f),
                           10, 10);
       else
         {
-          BView_ClipToRect (FRAME_HAIKU_VIEW (s->f), r[0].x,
+          BView_ClipToRect (FRAME_HAIKU_DRAWABLE (s->f), r[0].x,
                             r[0].y, r[0].width, r[0].height);
-          BView_invalidate_region (FRAME_HAIKU_VIEW (s->f), r[0].x,
+          BView_invalidate_region (FRAME_HAIKU_DRAWABLE (s->f), r[0].x,
                                    r[0].y, r[0].width, r[0].height);
         }
     }
@@ -181,15 +181,15 @@ haiku_clip_to_string (struct glyph_string *s)
       /* If n[FOO].width is 0, it means to not draw at all, so set the
          clipping to some impossible value.  */
       if (r[1].width <= 0)
-        BView_ClipToRect (FRAME_HAIKU_VIEW (s->f),
+        BView_ClipToRect (FRAME_HAIKU_DRAWABLE (s->f),
                           FRAME_PIXEL_WIDTH (s->f),
                           FRAME_PIXEL_HEIGHT (s->f),
                           10, 10);
       else
         {
-          BView_ClipToRect (FRAME_HAIKU_VIEW (s->f), r[1].x, r[1].y,
+          BView_ClipToRect (FRAME_HAIKU_DRAWABLE (s->f), r[1].x, r[1].y,
                             r[1].width, r[1].height);
-          BView_invalidate_region (FRAME_HAIKU_VIEW (s->f), r[1].x,
+          BView_invalidate_region (FRAME_HAIKU_DRAWABLE (s->f), r[1].x,
                                    r[1].y, r[1].width, r[1].height);
         }
     }
@@ -198,9 +198,9 @@ haiku_clip_to_string (struct glyph_string *s)
 static void
 haiku_clip_to_string_exactly (struct glyph_string *s, struct glyph_string *dst)
 {
-  BView_ClipToRect (FRAME_HAIKU_VIEW (s->f), s->x, s->y,
+  BView_ClipToRect (FRAME_HAIKU_DRAWABLE (s->f), s->x, s->y,
                     s->width, s->height);
-  BView_invalidate_region (FRAME_HAIKU_VIEW (s->f), s->x,
+  BView_invalidate_region (FRAME_HAIKU_DRAWABLE (s->f), s->x,
                            s->y, s->width, s->height);
 }
 
@@ -246,7 +246,7 @@ static void
 haiku_clear_frame_area (struct frame *f, int x, int y,
                         int width, int height)
 {
-  void *vw = FRAME_HAIKU_VIEW (f);
+  void *vw = FRAME_HAIKU_DRAWABLE (f);
   block_input ();
   BView_draw_lock (vw, true, x, y, width, height);
   BView_StartClip (vw);
@@ -261,7 +261,7 @@ haiku_clear_frame_area (struct frame *f, int x, int y,
 static void
 haiku_clear_frame (struct frame *f)
 {
-  void *view = FRAME_HAIKU_VIEW (f);
+  void *view = FRAME_HAIKU_DRAWABLE (f);
 
   mark_window_cursors_off (XWINDOW (FRAME_ROOT_WINDOW (f)));
 
@@ -596,7 +596,7 @@ haiku_draw_box_rect (struct glyph_string *s, int left_x, int top_y,
                      int right_x, int bottom_y, int hwidth, int vwidth,
                      bool left_p, bool right_p, struct haiku_rect *clip_rect)
 {
-  void *view = FRAME_HAIKU_VIEW (s->f);
+  void *view = FRAME_HAIKU_DRAWABLE (s->f);
   struct face *face = s->face;
 
   BView_SetHighColor (view, face->box_color);
@@ -660,7 +660,7 @@ haiku_draw_relief_rect (struct glyph_string *s, int left_x, int top_y,
   uint32_t color_white, color_black;
   void *view;
 
-  view = FRAME_HAIKU_VIEW (s->f);
+  view = FRAME_HAIKU_DRAWABLE (s->f);
   haiku_calculate_relief_colors (s, &color_white, &color_black);
 
   BView_SetHighColor (view, raised_p ? color_white : color_black);
@@ -769,7 +769,7 @@ haiku_draw_underwave (struct glyph_string *s, int width, int x)
   dy = wave_height - 1;
   y = s->ybase - wave_height + 3;
   xmax = x + width;
-  view = FRAME_HAIKU_VIEW (s->f);
+  view = FRAME_HAIKU_DRAWABLE (s->f);
 
   BView_StartClip (view);
   haiku_clip_to_string (s);
@@ -811,7 +811,7 @@ haiku_draw_text_decoration (struct glyph_string *s, struct face *face,
   if (s->hl == DRAW_CURSOR)
     haiku_merge_cursor_foreground (s, &cursor_color, NULL);
 
-  void *view = FRAME_HAIKU_VIEW (s->f);
+  void *view = FRAME_HAIKU_DRAWABLE (s->f);
 
   if (face->underline)
     {
@@ -1013,7 +1013,7 @@ static void
 haiku_draw_plain_background (struct glyph_string *s, struct face *face,
                              int x, int y, int width, int height)
 {
-  void *view = FRAME_HAIKU_VIEW (s->f);
+  void *view = FRAME_HAIKU_DRAWABLE (s->f);
   unsigned long cursor_color;
 
   if (s->hl == DRAW_CURSOR)
@@ -1075,7 +1075,7 @@ haiku_draw_stipple_background (struct glyph_string *s, struct face *face,
   unsigned long foreground, background;
   void *view;
 
-  view = FRAME_HAIKU_VIEW (s->f);
+  view = FRAME_HAIKU_DRAWABLE (s->f);
   rec = haiku_get_bitmap_rec (s->f, s->face->stipple);
 
   if (explicit_colors_p)
@@ -1173,7 +1173,7 @@ haiku_draw_glyph_string_foreground (struct glyph_string *s)
   else
     x = s->x;
 
-  void *view = FRAME_HAIKU_VIEW (s->f);
+  void *view = FRAME_HAIKU_DRAWABLE (s->f);
 
   if (s->font_not_found_p)
     {
@@ -1289,9 +1289,9 @@ haiku_draw_glyphless_glyph_string_foreground (struct glyph_string *s)
           else
             color = s->face->foreground;
 
-          BView_SetHighColor (FRAME_HAIKU_VIEW (s->f), color);
-          BView_SetPenSize (FRAME_HAIKU_VIEW (s->f), 1);
-          BView_StrokeRectangle (FRAME_HAIKU_VIEW (s->f),
+          BView_SetHighColor (FRAME_HAIKU_DRAWABLE (s->f), color);
+          BView_SetPenSize (FRAME_HAIKU_DRAWABLE (s->f), 1);
+          BView_StrokeRectangle (FRAME_HAIKU_DRAWABLE (s->f),
                                  x, s->ybase - glyph->ascent,
                                  glyph->pixel_width,
                                  glyph->ascent + glyph->descent);
@@ -1335,7 +1335,7 @@ haiku_draw_stretch_glyph_string (struct glyph_string *s)
       if (s->row->reversed_p)
         x -= width;
 
-      void *view = FRAME_HAIKU_VIEW (s->f);
+      void *view = FRAME_HAIKU_DRAWABLE (s->f);
       unsigned long cursor_color;
 
       haiku_merge_cursor_foreground (s, NULL, &cursor_color);
@@ -1401,14 +1401,14 @@ haiku_draw_stretch_glyph_string (struct glyph_string *s)
 static void
 haiku_start_clip (struct glyph_string *s)
 {
-  void *view = FRAME_HAIKU_VIEW (s->f);
+  void *view = FRAME_HAIKU_DRAWABLE (s->f);
   BView_StartClip (view);
 }
 
 static void
 haiku_end_clip (struct glyph_string *s)
 {
-  void *view = FRAME_HAIKU_VIEW (s->f);
+  void *view = FRAME_HAIKU_DRAWABLE (s->f);
   BView_EndClip (view);
 }
 
@@ -1428,7 +1428,7 @@ haiku_clip_to_row (struct window *w, struct glyph_row *row,
   width = window_width;
   height = row->visible_height;
 
-  BView_ClipToRect (FRAME_HAIKU_VIEW (f), x, y, width, height);
+  BView_ClipToRect (FRAME_HAIKU_DRAWABLE (f), x, y, width, height);
 }
 
 static void
@@ -1448,7 +1448,7 @@ haiku_draw_composite_glyph_string_foreground (struct glyph_string *s)
 {
   int i, j, x;
   struct font *font = s->font;
-  void *view = FRAME_HAIKU_VIEW (s->f);
+  void *view = FRAME_HAIKU_DRAWABLE (s->f);
   struct face *face = s->face;
 
   /* If first glyph of S has a left box line, start drawing the text
@@ -1670,7 +1670,7 @@ haiku_draw_image_glyph_string (struct glyph_string *s)
   if (s->slice.y == 0)
     y += box_line_vwidth;
 
-  view = FRAME_HAIKU_VIEW (s->f);
+  view = FRAME_HAIKU_DRAWABLE (s->f);
   bitmap = s->img->pixmap;
 
   s->stippled_p = face->stipple != 0;
@@ -1803,7 +1803,7 @@ haiku_draw_image_glyph_string (struct glyph_string *s)
 static void
 haiku_draw_glyph_string (struct glyph_string *s)
 {
-  void *view = FRAME_HAIKU_VIEW (s->f);;
+  void *view = FRAME_HAIKU_DRAWABLE (s->f);;
   struct face *face = s->face;
 
   block_input ();
@@ -2001,7 +2001,7 @@ haiku_after_update_window_line (struct window *w,
       block_input ();
       if (face)
         {
-          void *view = FRAME_HAIKU_VIEW (f);
+          void *view = FRAME_HAIKU_DRAWABLE (f);
           BView_draw_lock (view, false, 0, 0, 0, 0);
           BView_StartClip (view);
           BView_SetHighColor (view, (face->background_defaulted_p
@@ -2010,7 +2010,7 @@ haiku_after_update_window_line (struct window *w,
           BView_FillRectangle (view, 0, y, width, height);
           BView_FillRectangle (view, FRAME_PIXEL_WIDTH (f) - width,
                                y, width, height);
-          BView_invalidate_region (FRAME_HAIKU_VIEW (f),
+          BView_invalidate_region (FRAME_HAIKU_DRAWABLE (f),
                                    0, y, width, height);
           BView_invalidate_region (view, FRAME_PIXEL_WIDTH (f) - width,
                                    y, width, height);
@@ -2075,7 +2075,7 @@ haiku_draw_hollow_cursor (struct window *w, struct glyph_row *row)
   void *view;
 
   f = XFRAME (WINDOW_FRAME (w));
-  view = FRAME_HAIKU_VIEW (f);
+  view = FRAME_HAIKU_DRAWABLE (f);
 
   /* Get the glyph the cursor is on.  If we can't tell because
      the current matrix is invalid or such, give up.  */
@@ -2148,7 +2148,7 @@ haiku_draw_bar_cursor (struct window *w, struct glyph_row *row,
     }
   else
     {
-      view = FRAME_HAIKU_VIEW (f);
+      view = FRAME_HAIKU_DRAWABLE (f);
       face = FACE_FROM_ID (f, cursor_glyph->face_id);
 
       /* If the glyph's background equals the color we normally draw
@@ -2334,7 +2334,7 @@ haiku_draw_vertical_window_border (struct window *w,
   struct face *face;
 
   face = FACE_FROM_ID_OR_NULL (f, VERTICAL_BORDER_FACE_ID);
-  void *view = FRAME_HAIKU_VIEW (f);
+  void *view = FRAME_HAIKU_DRAWABLE (f);
   BView_draw_lock (view, true, x, y_0, 1, y_1);
   BView_StartClip (view);
   if (face)
@@ -2384,7 +2384,7 @@ haiku_draw_window_divider (struct window *w, int x0, int x1, int y0, int y1)
   unsigned long color_last = (face_last
                               ? face_last->foreground
                               : FRAME_FOREGROUND_PIXEL (f));
-  void *view = FRAME_HAIKU_VIEW (f);
+  void *view = FRAME_HAIKU_DRAWABLE (f);
 
   BView_draw_lock (view, true, x0, y0, x1 - x0 + 1, y1 - y0 + 1);
   BView_StartClip (view);
@@ -2554,7 +2554,7 @@ haiku_scroll_bar_create (struct window *w, int left, int top,
   void *view;
 
   f = XFRAME (WINDOW_FRAME (w));
-  view = FRAME_HAIKU_VIEW (f);
+  view = FRAME_HAIKU_DRAWABLE (f);
 
   block_input ();
   bar = ALLOCATE_PSEUDOVECTOR (struct scroll_bar, prev, PVEC_OTHER);
@@ -2604,7 +2604,7 @@ haiku_set_horizontal_scroll_bar (struct window *w, int portion, int whole, int p
   width = window_width;
   top = WINDOW_SCROLL_BAR_AREA_Y (w);
   height = WINDOW_CONFIG_SCROLL_BAR_HEIGHT (w);
-  view = FRAME_HAIKU_VIEW (WINDOW_XFRAME (w));
+  view = FRAME_HAIKU_DRAWABLE (WINDOW_XFRAME (w));
 
   block_input ();
 
@@ -2663,7 +2663,7 @@ haiku_set_vertical_scroll_bar (struct window *w, int portion, int whole, int pos
   left = WINDOW_SCROLL_BAR_AREA_X (w);
   width = WINDOW_SCROLL_BAR_AREA_WIDTH (w);
 
-  view = FRAME_HAIKU_VIEW (WINDOW_XFRAME (w));
+  view = FRAME_HAIKU_DRAWABLE (WINDOW_XFRAME (w));
 
   block_input ();
   if (NILP (w->vertical_scroll_bar))
@@ -2712,7 +2712,7 @@ haiku_draw_fringe_bitmap (struct window *w, struct glyph_row *row,
   uint32 col;
 
   f = XFRAME (WINDOW_FRAME (w));
-  view = FRAME_HAIKU_VIEW (f);
+  view = FRAME_HAIKU_DRAWABLE (f);
   face = p->face;
 
   block_input ();
@@ -2828,7 +2828,7 @@ static void
 haiku_scroll_run (struct window *w, struct run *run)
 {
   struct frame *f = XFRAME (w->frame);
-  void *view = FRAME_HAIKU_VIEW (f);
+  void *view = FRAME_HAIKU_DRAWABLE (f);
   int x, y, width, height, from_y, to_y, bottom_y;
   window_box (w, ANY_AREA, &x, &y, &width, &height);
 
@@ -3211,9 +3211,9 @@ haiku_read_socket (struct terminal *terminal, struct input_event *hold_quit)
                 continue;
               }
 
-            BView_draw_lock (FRAME_HAIKU_VIEW (f), false, 0, 0, 0, 0);
-            BView_resize_to (FRAME_HAIKU_VIEW (f), width, height);
-            BView_draw_unlock (FRAME_HAIKU_VIEW (f));
+            BView_draw_lock (FRAME_HAIKU_DRAWABLE (f), false, 0, 0, 0, 0);
+            BView_resize_to (FRAME_HAIKU_DRAWABLE (f), width, height);
+            BView_draw_unlock (FRAME_HAIKU_DRAWABLE (f));
 
             if (width != FRAME_PIXEL_WIDTH (f)
                 || height != FRAME_PIXEL_HEIGHT (f)
@@ -4126,7 +4126,7 @@ haiku_flash (struct frame *f)
   int flash_left = FRAME_INTERNAL_BORDER_WIDTH (f);
   int flash_right = FRAME_PIXEL_WIDTH (f) - FRAME_INTERNAL_BORDER_WIDTH (f);
   int width = flash_right - flash_left;
-  void *view = FRAME_HAIKU_VIEW (f);
+  void *view = FRAME_HAIKU_DRAWABLE (f);
   object_wait_info info;
   bigtime_t wakeup;
 
@@ -4454,7 +4454,7 @@ haiku_clear_under_internal_border (struct frame *f)
             ? lookup_basic_face (NULL, f, INTERNAL_BORDER_FACE_ID)
             : INTERNAL_BORDER_FACE_ID));
       struct face *face = FACE_FROM_ID_OR_NULL (f, face_id);
-      void *view = FRAME_HAIKU_VIEW (f);
+      void *view = FRAME_HAIKU_DRAWABLE (f);
 
       block_input ();
       BView_draw_lock (view, true, 0, 0, FRAME_PIXEL_WIDTH (f),
@@ -4496,7 +4496,7 @@ haiku_scroll_bar_remove (struct scroll_bar *bar)
   struct frame *f;
 
   f = WINDOW_XFRAME (XWINDOW (bar->window));
-  view = FRAME_HAIKU_VIEW (f);
+  view = FRAME_HAIKU_DRAWABLE (f);
 
   block_input ();
   BView_forget_scroll_bar (view, bar->left, bar->top,
diff --git a/src/haikuterm.h b/src/haikuterm.h
index 02a364f6712..b603c0a482f 100644
--- a/src/haikuterm.h
+++ b/src/haikuterm.h
@@ -275,7 +275,8 @@ struct scroll_bar
 #define MAKE_FRAME_DIRTY(f)             (FRAME_DIRTY_P (f) = 1)
 #define FRAME_OUTPUT_DATA(f)            ((f)->output_data.haiku)
 #define FRAME_HAIKU_WINDOW(f)           (FRAME_OUTPUT_DATA (f)->window)
-#define FRAME_HAIKU_VIEW(f)             ((MAKE_FRAME_DIRTY (f)), FRAME_OUTPUT_DATA (f)->view)
+#define FRAME_HAIKU_VIEW(f)             (FRAME_OUTPUT_DATA (f)->view)
+#define FRAME_HAIKU_DRAWABLE(f)         ((MAKE_FRAME_DIRTY (f)), FRAME_HAIKU_VIEW (f))
 #define FRAME_HAIKU_MENU_BAR(f)         (FRAME_OUTPUT_DATA (f)->menubar)
 #define FRAME_DISPLAY_INFO(f)           (FRAME_OUTPUT_DATA (f)->display_info)
 #define FRAME_FONT(f)                   (FRAME_OUTPUT_DATA (f)->font)
@@ -287,7 +288,7 @@ struct scroll_bar
 #ifdef USE_BE_CAIRO
 #define FRAME_CR_CONTEXT(f)                                     \
   (FRAME_HAIKU_VIEW (f)                                         \
-   ? EmacsView_cairo_context (FRAME_HAIKU_VIEW (f))             \
+   ? EmacsView_cairo_context (FRAME_HAIKU_DRAWABLE (f))         \
    : NULL)
 #endif
 
diff --git a/src/indent.c b/src/indent.c
index fd2e7636656..d2dfaee254e 100644
--- a/src/indent.c
+++ b/src/indent.c
@@ -2345,7 +2345,15 @@ whether or not it is currently displayed in some window.  */)
              last line that it occupies.  */
           if (it_start < ZV)
             {
-              while (IT_CHARPOS (it) <= it_start)
+              if ((it.bidi_it.scan_dir > 0)
+                  ? IT_CHARPOS (it) < it_start
+                  : IT_CHARPOS (it) > it_start)
+                {
+                  it.vpos = 0;
+                  it.current_y = 0;
+                  move_it_by_lines (&it, 1);
+                }
+              while (IT_CHARPOS (it) == it_start)
                 {
                   it.vpos = 0;
                   it.current_y = 0;
diff --git a/src/keyboard.c b/src/keyboard.c
index 2863058d633..719226caedc 100644
--- a/src/keyboard.c
+++ b/src/keyboard.c
@@ -1295,7 +1295,8 @@ command_loop_1 (void)
       /* Note that the value cell will never directly contain nil
          if the symbol is a local variable.  */
       if (!NILP (Vpost_command_hook) && !NILP (Vrun_hooks))
-        safe_run_hooks (Qpost_command_hook);
+        safe_run_hooks_maybe_narrowed (Qpost_command_hook,
+                                       XWINDOW (selected_window));
 
       /* If displaying a message, resize the echo area window to fit
          that message's size exactly.  */
@@ -1330,6 +1331,7 @@ command_loop_1 (void)
         display_malloc_warning ();
 
       Vdeactivate_mark = Qnil;
+      backtrace_yet = false;
 
       /* Don't ignore mouse movements for more than a single command
          loop.  (This flag is set in xdisp.c whenever the tool bar is
@@ -1461,7 +1463,9 @@ command_loop_1 (void)
       }
       Vthis_command = cmd;
       Vreal_this_command = cmd;
-      safe_run_hooks (Qpre_command_hook);
+
+      safe_run_hooks_maybe_narrowed (Qpre_command_hook,
+                                     XWINDOW (selected_window));
 
       already_adjusted = 0;
 
@@ -1513,7 +1517,8 @@ command_loop_1 (void)
           }
       kset_last_prefix_arg (current_kboard, Vcurrent_prefix_arg);
 
-      safe_run_hooks (Qpost_command_hook);
+      safe_run_hooks_maybe_narrowed (Qpost_command_hook,
+                                     XWINDOW (selected_window));
 
       /* If displaying a message, resize the echo area window to fit
          that message's size exactly.  Do this only if the echo area
@@ -1837,7 +1842,7 @@ safe_run_hooks_1 (ptrdiff_t nargs, Lisp_Object *args)
 static Lisp_Object
 safe_run_hooks_error (Lisp_Object error, ptrdiff_t nargs, Lisp_Object *args)
 {
-  eassert (nargs == 2);
+  eassert (nargs >= 2 && nargs <= 4);
   AUTO_STRING (format, "Error in %s (%S): %S");
   Lisp_Object hook = args[0];
   Lisp_Object fun = args[1];
@@ -1895,6 +1900,33 @@ safe_run_hooks (Lisp_Object hook)
   unbind_to (count, Qnil);
 }
 
+void
+safe_run_hooks_maybe_narrowed (Lisp_Object hook, struct window *w)
+{
+  specpdl_ref count = SPECPDL_INDEX ();
+
+  specbind (Qinhibit_quit, Qt);
+
+  if (current_buffer->long_line_optimizations_p)
+    narrow_to_region_internal (make_fixnum (get_narrowed_begv (w, PT)),
+                               make_fixnum (get_narrowed_zv (w, PT)),
+                               true);
+
+  run_hook_with_args (2, ((Lisp_Object []) {hook, hook}), safe_run_hook_funcall);
+  unbind_to (count, Qnil);
+}
+
+void
+safe_run_hooks_2 (Lisp_Object hook, Lisp_Object arg1, Lisp_Object arg2)
+{
+  specpdl_ref count = SPECPDL_INDEX ();
+
+  specbind (Qinhibit_quit, Qt);
+  run_hook_with_args (4, ((Lisp_Object []) {hook, hook, arg1, arg2}),
+                      safe_run_hook_funcall);
+  unbind_to (count, Qnil);
+}
+
 
 /* Nonzero means polling for input is temporarily suppressed.  */
 
@@ -4622,6 +4654,11 @@ timer_check_2 (Lisp_Object timers, Lisp_Object idle_timers)
       /* If timer is ripe, run it if it hasn't been run.  */
       if (ripe)
         {
+          /* If we got here, presumably `decode_timer` has checked
+             that this timer has not yet been triggered.  */
+          eassert (NILP (AREF (chosen_timer, 0)));
+          /* In a production build, where assertions compile to
+             nothing, we still want to play it safe here.  */
           if (NILP (AREF (chosen_timer, 0)))
             {
               specpdl_ref count = SPECPDL_INDEX ();
@@ -4640,8 +4677,8 @@ timer_check_2 (Lisp_Object timers, Lisp_Object idle_timers)
 
               /* Since we have handled the event,
                  we don't need to tell the caller to wake up and do it.  */
-              /* But the caller must still wait for the next timer, so
-                 return 0 to indicate that.  */
+              /* But the caller must still wait for the next timer, so
+                 return 0 to indicate that.  */
             }
 
           nexttime = make_timespec (0, 0);
@@ -12622,23 +12659,39 @@ Buffer modification stores t in this variable.  */);
 
   DEFVAR_LISP ("pre-command-hook", Vpre_command_hook,
                doc: /* Normal hook run before each command is executed.
-If an unhandled error happens in running this hook,
-the function in which the error occurred is unconditionally removed, since
-otherwise the error might happen repeatedly and make Emacs nonfunctional.
+
+If an unhandled error happens in running this hook, the function in
+which the error occurred is unconditionally removed, since otherwise
+the error might happen repeatedly and make Emacs nonfunctional.
+
+Note that, when the current buffer contains one or more lines whose
+length is above `long-line-threshold', these hook functions are called
+with the buffer narrowed to a small portion around point, and the
+narrowing is locked (see `narrow-to-region'), so that these hook
+functions cannot use `widen' to gain access to other portions of
+buffer text.
 
 See also `post-command-hook'.  */);
   Vpre_command_hook = Qnil;
 
   DEFVAR_LISP ("post-command-hook", Vpost_command_hook,
                doc: /* Normal hook run after each command is executed.
-If an unhandled error happens in running this hook,
-the function in which the error occurred is unconditionally removed, since
-otherwise the error might happen repeatedly and make Emacs nonfunctional.
+
+If an unhandled error happens in running this hook, the function in
+which the error occurred is unconditionally removed, since otherwise
+the error might happen repeatedly and make Emacs nonfunctional.
 
 It is a bad idea to use this hook for expensive processing.  If
 unavoidable, wrap your code in `(while-no-input (redisplay) CODE)' to
 avoid making Emacs unresponsive while the user types.
 
+Note that, when the current buffer contains one or more lines whose
+length is above `long-line-threshold', these hook functions are called
+with the buffer narrowed to a small portion around point, and the
+narrowing is locked (see `narrow-to-region'), so that these hook
+functions cannot use `widen' to gain access to other portions of
+buffer text.
+
 See also `pre-command-hook'.  */);
   Vpost_command_hook = Qnil;
 
@@ -12914,7 +12967,10 @@ This variable only has an effect when Transient Mark mode is enabled.
 
 If the value is `only', only temporarily active regions (usually made
 by mouse-dragging or shift-selection) set the window system's primary
-selection.  */);
+selection.
+
+If this variable causes the region to be set as the primary selection,
+`post-select-region-hook' is then run afterwards.  */);
   Vselect_active_regions = Qt;
 
   DEFVAR_LISP ("saved-region-selection",
diff --git a/src/lisp.h b/src/lisp.h
index 8fcc9b6e75a..2f73ba4c617 100644
--- a/src/lisp.h
+++ b/src/lisp.h
@@ -3793,10 +3793,10 @@ make_symbol_constant (Lisp_Object sym)
 
 /* Buffer-local variable access functions.  */
 
-INLINE int
+INLINE bool
 blv_found (struct Lisp_Buffer_Local_Value *blv)
 {
-  eassert (blv->found == !EQ (blv->defcell, blv->valcell));
+  eassert (blv->found == !BASE_EQ (blv->defcell, blv->valcell));
   return blv->found;
 }
 
@@ -4530,6 +4530,7 @@ extern Lisp_Object Vrun_hooks;
 extern Lisp_Object Vsignaling_function;
 extern Lisp_Object inhibit_lisp_code;
 extern bool signal_quit_p (Lisp_Object);
+extern bool backtrace_yet;
 
 /* To run a normal hook, use the appropriate function from the list below.
    The calling convention:
@@ -4679,6 +4680,7 @@ extern void save_restriction_restore (Lisp_Object);
 extern Lisp_Object make_buffer_string (ptrdiff_t, ptrdiff_t, bool);
 extern Lisp_Object make_buffer_string_both (ptrdiff_t, ptrdiff_t, ptrdiff_t,
                                             ptrdiff_t, bool);
+extern Lisp_Object narrow_to_region_internal (Lisp_Object, Lisp_Object, bool);
 extern void init_editfns (void);
 extern void syms_of_editfns (void);
 
@@ -4829,6 +4831,8 @@ extern bool detect_input_pending (void);
 extern bool detect_input_pending_ignore_squeezables (void);
 extern bool detect_input_pending_run_timers (bool);
 extern void safe_run_hooks (Lisp_Object);
+extern void safe_run_hooks_maybe_narrowed (Lisp_Object, struct window *);
+extern void safe_run_hooks_2 (Lisp_Object, Lisp_Object, Lisp_Object);
 extern void cmd_error_internal (Lisp_Object, const char *);
 extern Lisp_Object command_loop_2 (Lisp_Object);
 extern Lisp_Object read_menu_command (void);
@@ -4941,7 +4945,8 @@ extern void setup_process_coding_systems (Lisp_Object);
 #endif
 
 extern int emacs_spawn (pid_t *, int, int, int, char **, char **,
-                        const char *, const char *, const sigset_t *);
+                        const char *, const char *, bool, bool,
+                        const sigset_t *);
 extern char **make_environment_block (Lisp_Object) ATTRIBUTE_RETURNS_NONNULL;
 extern void init_callproc_1 (void);
 extern void init_callproc (void);
diff --git a/src/lread.c b/src/lread.c
index 0720774db2b..ccccd79cd7c 100644
--- a/src/lread.c
+++ b/src/lread.c
@@ -131,25 +131,15 @@ static ptrdiff_t read_from_string_limit;
 /* Position in object from which characters are being read by `readchar'.  */
 static EMACS_INT readchar_offset;
 
-/* This contains the last string skipped with #@.  */
-static char *saved_doc_string;
-/* Length of buffer allocated in saved_doc_string.  */
-static ptrdiff_t saved_doc_string_size;
-/* Length of actual data in saved_doc_string.  */
-static ptrdiff_t saved_doc_string_length;
-/* This is the file position that string came from.  */
-static file_offset saved_doc_string_position;
-
-/* This contains the previous string skipped with #@.
-   We copy it from saved_doc_string when a new string
-   is put in saved_doc_string.  */
-static char *prev_saved_doc_string;
-/* Length of buffer allocated in prev_saved_doc_string.  */
-static ptrdiff_t prev_saved_doc_string_size;
-/* Length of actual data in prev_saved_doc_string.  */
-static ptrdiff_t prev_saved_doc_string_length;
-/* This is the file position that string came from.  */
-static file_offset prev_saved_doc_string_position;
+struct saved_string {
+  char *string;                 /* string in allocated buffer */
+  ptrdiff_t size;               /* allocated size of buffer */
+  ptrdiff_t length;             /* length of string in buffer */
+  file_offset position;         /* position in file the string came from */
+};
+
+/* The last two strings skipped with #@ (most recent first).  */
+static struct saved_string saved_strings[2];
 
 /* A list of file names for files being loaded in Fload.  Used to
    check for recursive loads.  */
@@ -1605,13 +1595,12 @@ Return t if the file exists and loads successfully.  */)
   if (!NILP (Ffboundp (Qdo_after_load_evaluation)))
     call1 (Qdo_after_load_evaluation, hist_file_name) ;
 
-  xfree (saved_doc_string);
-  saved_doc_string = 0;
-  saved_doc_string_size = 0;
-
-  xfree (prev_saved_doc_string);
-  prev_saved_doc_string = 0;
-  prev_saved_doc_string_size = 0;
+  for (int i = 0; i < ARRAYELTS (saved_strings); i++)
+    {
+      xfree (saved_strings[i].string);
+      saved_strings[i].string = NULL;
+      saved_strings[i].size = 0;
+    }
 
   if (!noninteractive && (NILP (nomessage) || force_load_messages))
     {
@@ -2261,7 +2250,7 @@ readevalloop (Lisp_Object readcharfun,
           /* Set point and ZV around stuff to be read.  */
           Fgoto_char (start);
           if (!NILP (end))
-            Fnarrow_to_region (make_fixnum (BEGV), end, Qnil);
+            Fnarrow_to_region (make_fixnum (BEGV), end);
 
           /* Just for cleanliness, convert END to a marker
              if it is an integer.  */
@@ -3056,7 +3045,6 @@ read_string_literal (char stackbuf[VLA_ELEMS (stackbufsize)],
   /* True if we saw an escape sequence specifying
      a single-byte character.  */
   bool force_singlebyte = false;
-  bool cancel = false;
   ptrdiff_t nchars = 0;
 
   int ch;
@@ -3085,8 +3073,6 @@ read_string_literal (char stackbuf[VLA_ELEMS (stackbufsize)],
             case ' ':
             case '\n':
               /* `\SPC' and `\LF' generate no characters at all.  */
-              if (p == read_buffer)
-                cancel = true;
               continue;
             default:
               UNREAD (ch);
@@ -3152,15 +3138,6 @@ read_string_literal (char stackbuf[VLA_ELEMS (stackbufsize)],
   if (ch < 0)
     end_of_file_error ();
 
-  /* If purifying, and string starts with \ newline,
-     return zero instead.  This is for doc strings
-     that we are really going to find in etc/DOC.nn.nn.  */
-  if (!NILP (Vpurify_flag) && NILP (Vdoc_file_name) && cancel)
-    {
-      unbind_to (count, Qnil);
-      return make_fixnum (0);
-    }
-
   if (!force_multibyte && force_singlebyte)
     {
       /* READ_BUFFER contains raw 8-bit bytes and no multibyte
@@ -3457,57 +3434,95 @@ skip_lazy_string (Lisp_Object readcharfun)
          record the last string that we skipped,
          and record where in the file it comes from.  */
 
-      /* But first exchange saved_doc_string
-         with prev_saved_doc_string, so we save two strings.  */
-      {
-        char *temp = saved_doc_string;
-        ptrdiff_t temp_size = saved_doc_string_size;
-        file_offset temp_pos = saved_doc_string_position;
-        ptrdiff_t temp_len = saved_doc_string_length;
-
-        saved_doc_string = prev_saved_doc_string;
-        saved_doc_string_size = prev_saved_doc_string_size;
-        saved_doc_string_position = prev_saved_doc_string_position;
-        saved_doc_string_length = prev_saved_doc_string_length;
-
-        prev_saved_doc_string = temp;
-        prev_saved_doc_string_size = temp_size;
-        prev_saved_doc_string_position = temp_pos;
-        prev_saved_doc_string_length = temp_len;
-      }
+      /* First exchange the two saved_strings.  */
+      verify (ARRAYELTS (saved_strings) == 2);
+      struct saved_string t = saved_strings[0];
+      saved_strings[0] = saved_strings[1];
+      saved_strings[1] = t;
 
       enum { extra = 100 };
-      if (saved_doc_string_size == 0)
+      struct saved_string *ss = &saved_strings[0];
+      if (ss->size == 0)
         {
-          saved_doc_string = xmalloc (nskip + extra);
-          saved_doc_string_size = nskip + extra;
+          ss->size = nskip + extra;
+          ss->string = xmalloc (ss->size);
         }
-      if (nskip > saved_doc_string_size)
+      else if (nskip > ss->size)
         {
-          saved_doc_string = xrealloc (saved_doc_string, nskip + extra);
-          saved_doc_string_size = nskip + extra;
+          ss->size = nskip + extra;
+          ss->string = xrealloc (ss->string, ss->size);
         }
 
       FILE *instream = infile->stream;
-      saved_doc_string_position = (file_tell (instream) - infile->lookahead);
+      ss->position = (file_tell (instream) - infile->lookahead);
 
-      /* Copy that many bytes into saved_doc_string.  */
+      /* Copy that many bytes into the saved string.  */
       ptrdiff_t i = 0;
       int c = 0;
       for (int n = min (nskip, infile->lookahead); n > 0; n--)
-        saved_doc_string[i++] = c = infile->buf[--infile->lookahead];
+        ss->string[i++] = c = infile->buf[--infile->lookahead];
       block_input ();
       for (; i < nskip && c >= 0; i++)
-        saved_doc_string[i] = c = getc (instream);
+        ss->string[i] = c = getc (instream);
       unblock_input ();
 
-      saved_doc_string_length = i;
+      ss->length = i;
     }
   else
     /* Skip that many bytes.  */
     skip_dyn_bytes (readcharfun, nskip);
 }
 
+/* Given a lazy-loaded string designator VAL, return the actual string.
+   VAL is (FILENAME . POS).  */
+static Lisp_Object
+get_lazy_string (Lisp_Object val)
+{
+  /* Get a doc string from the file we are loading.
+     If it's in a saved string, get it from there.
+
+     Here, we don't know if the string is a bytecode string or a doc
+     string.  As a bytecode string must be unibyte, we always return a
+     unibyte string.  If it is actually a doc string, caller must make
+     it multibyte.  */
+
+  /* We used to emit negative positions for 'user variables' (whose doc
+     strings started with an asterisk); take the absolute value for
+     compatibility.  */
+  EMACS_INT pos = eabs (XFIXNUM (XCDR (val)));
+  struct saved_string *ss = &saved_strings[0];
+  struct saved_string *ssend = ss + ARRAYELTS (saved_strings);
+  while (ss < ssend
+         && !(pos >= ss->position && pos < ss->position + ss->length))
+    ss++;
+  if (ss >= ssend)
+    return get_doc_string (val, 1, 0);
+
+  ptrdiff_t start = pos - ss->position;
+  char *str = ss->string;
+  ptrdiff_t from = start;
+  ptrdiff_t to = start;
+
+  /* Process quoting with ^A, and find the end of the string,
+     which is marked with ^_ (037).  */
+  while (str[from] != 037)
+    {
+      int c = str[from++];
+      if (c == 1)
+        {
+          c = str[from++];
+          str[to++] = (c == 1 ? c
+                       : c == '0' ? 0
+                       : c == '_' ? 037
+                       : c);
+        }
+      else
+        str[to++] = c;
+    }
+
+  return make_unibyte_string (str + start, to - start);
+}
+
 
 /* Length of prefix only consisting of symbol constituent characters.  */
 static ptrdiff_t
@@ -4249,6 +4264,15 @@ read0 (Lisp_Object readcharfun, bool locate_syms)
             XSETCDR (e->u.list.tail, obj);
             read_stack_pop ();
             obj = e->u.list.head;
+
+            /* Hack: immediately convert (#$ . FIXNUM) to the corresponding
+               string if load-force-doc-strings is set.  */
+            if (load_force_doc_strings
+                && BASE_EQ (XCAR (obj), Vload_file_name)
+                && !NILP (XCAR (obj))
+                && FIXNUMP (XCDR (obj)))
+              obj = get_lazy_string (obj);
+
             break;
           }
 
diff --git a/src/marker.c b/src/marker.c
index 3c8e628762e..9727586f424 100644
--- a/src/marker.c
+++ b/src/marker.c
@@ -214,11 +214,12 @@ buf_charpos_to_bytepos (struct buffer *b, ptrdiff_t charpos)
      We have one known above and one known below.
      Scan, counting characters, from whichever one is closer.  */
 
+  eassert (best_below <= charpos && charpos <= best_above);
   if (charpos - best_below < best_above - charpos)
     {
       bool record = charpos - best_below > 5000;
 
-      while (best_below != charpos)
+      while (best_below < charpos)
         {
           best_below++;
           best_below_byte += buf_next_char_len (b, best_below_byte);
@@ -243,7 +244,7 @@ buf_charpos_to_bytepos (struct buffer *b, ptrdiff_t charpos)
     {
       bool record = best_above - charpos > 5000;
 
-      while (best_above != charpos)
+      while (best_above > charpos)
         {
           best_above--;
           best_above_byte -= buf_prev_char_len (b, best_above_byte);
diff --git a/src/nsfns.m b/src/nsfns.m
index 433df059610..1d3dcd31243 100644
--- a/src/nsfns.m
+++ b/src/nsfns.m
@@ -1057,6 +1057,7 @@ frame_parm_handler ns_frame_parm_handlers[] =
   0, /* x_set_override_redirect */
   gui_set_no_special_glyphs,
   gui_set_alpha_background,
+  NULL,
 #ifdef NS_IMPL_COCOA
   ns_set_appearance,
   ns_set_transparent_titlebar,
diff --git a/src/pgtkfns.c b/src/pgtkfns.c
index d998c3d938c..beaf28f69d9 100644
--- a/src/pgtkfns.c
+++ b/src/pgtkfns.c
@@ -991,6 +991,7 @@ frame_parm_handler pgtk_frame_parm_handlers[] =
     pgtk_set_override_redirect,
     gui_set_no_special_glyphs,
     pgtk_set_alpha_background,
+    NULL,
   };
 
 
diff --git a/src/print.c b/src/print.c
index 7303e847aa2..1c96ec14b86 100644
--- a/src/print.c
+++ b/src/print.c
@@ -63,16 +63,17 @@ static Lisp_Object being_printed[PRINT_CIRCLE];
 /* Last char printed to stdout by printchar.  */
 static unsigned int printchar_stdout_last;
 
+struct print_buffer
+{
+  char *buffer;                 /* Allocated buffer.  */
+  ptrdiff_t size;               /* Size of allocated buffer.  */
+  ptrdiff_t pos;                /* Chars stored in buffer.  */
+  ptrdiff_t pos_byte;           /* Bytes stored in buffer.  */
+};
+
 /* When printing into a buffer, first we put the text in this
    block, then insert it all at once.  */
-static char *print_buffer;
-
-/* Size allocated in print_buffer.  */
-static ptrdiff_t print_buffer_size;
-/* Chars stored in print_buffer.  */
-static ptrdiff_t print_buffer_pos;
-/* Bytes stored in print_buffer.  */
-static ptrdiff_t print_buffer_pos_byte;
+static struct print_buffer print_buffer;
 
 /* Vprint_number_table is a table, that keeps objects that are going to
    be printed, to allow use of #n= and #n# to express sharing.
@@ -91,121 +92,139 @@ bool print_output_debug_flag EXTERNALLY_VISIBLE = 1;
 
 /* Low level output routines for characters and strings.  */
 
-/* Lisp functions to do output using a stream
-   must have the stream in a variable called printcharfun
-   and must start with PRINTPREPARE, end with PRINTFINISH.
-   Use printchar to output one character,
-   or call strout to output a block of characters.  */
-
-#define PRINTPREPARE                                                    \
-   ptrdiff_t old_point = -1, start_point = -1;                          \
-   ptrdiff_t old_point_byte = -1, start_point_byte = -1;                \
-   specpdl_ref specpdl_count = SPECPDL_INDEX ();                        \
-   bool multibyte                                                       \
-     = !NILP (BVAR (current_buffer, enable_multibyte_characters));      \
-   Lisp_Object original = printcharfun;                                 \
-   record_unwind_current_buffer ();                                     \
-   specbind(Qprint__unreadable_callback_buffer, Fcurrent_buffer ());    \
-   if (NILP (printcharfun)) printcharfun = Qt;                          \
-   if (BUFFERP (printcharfun))                                          \
-     {                                                                  \
-       if (XBUFFER (printcharfun) != current_buffer)                    \
-         Fset_buffer (printcharfun);                                    \
-       printcharfun = Qnil;                                             \
-     }                                                                  \
-   if (MARKERP (printcharfun))                                          \
-     {                                                                  \
-       ptrdiff_t marker_pos;                                            \
-       if (! XMARKER (printcharfun)->buffer)                            \
-         error ("Marker does not point anywhere");                      \
-       if (XMARKER (printcharfun)->buffer != current_buffer)            \
-         set_buffer_internal (XMARKER (printcharfun)->buffer);          \
-       marker_pos = marker_position (printcharfun);                     \
-       if (marker_pos < BEGV || marker_pos > ZV)                        \
-         signal_error ("Marker is outside the accessible "              \
-                       "part of the buffer", printcharfun);             \
-       old_point = PT;                                                  \
-       old_point_byte = PT_BYTE;                                        \
-       SET_PT_BOTH (marker_pos,                                         \
-                    marker_byte_position (printcharfun));               \
-       start_point = PT;                                                \
-       start_point_byte = PT_BYTE;                                      \
-       printcharfun = Qnil;                                             \
-     }                                                                  \
-   if (NILP (printcharfun))                                             \
-     {                                                                  \
-       Lisp_Object string;                                              \
-       if (NILP (BVAR (current_buffer, enable_multibyte_characters))    \
-           && ! print_escape_multibyte)                                 \
-         specbind (Qprint_escape_multibyte, Qt);                        \
-       if (! NILP (BVAR (current_buffer, enable_multibyte_characters))  \
-           && ! print_escape_nonascii)                                  \
-         specbind (Qprint_escape_nonascii, Qt);                         \
-       if (print_buffer != 0)                                           \
-         {                                                              \
-           string = make_string_from_bytes (print_buffer,               \
-                                            print_buffer_pos,           \
-                                            print_buffer_pos_byte);     \
-           record_unwind_protect (print_unwind, string);                \
-         }                                                              \
-       else                                                             \
-         {                                                              \
-           int new_size = 1000;                                         \
-           print_buffer = xmalloc (new_size);                           \
-           print_buffer_size = new_size;                                \
-           record_unwind_protect_void (print_free_buffer);              \
-         }                                                              \
-       print_buffer_pos = 0;                                            \
-       print_buffer_pos_byte = 0;                                       \
-     }                                                                  \
-   if (EQ (printcharfun, Qt) && ! noninteractive)                       \
-     setup_echo_area_for_printing (multibyte);
-
-#define PRINTFINISH                                                     \
-   if (NILP (printcharfun))                                             \
-     {                                                                  \
-       if (print_buffer_pos != print_buffer_pos_byte                    \
-           && NILP (BVAR (current_buffer, enable_multibyte_characters)))\
-         {                                                              \
-           USE_SAFE_ALLOCA;                                             \
-           unsigned char *temp = SAFE_ALLOCA (print_buffer_pos + 1);    \
-           copy_text ((unsigned char *) print_buffer, temp,             \
-                      print_buffer_pos_byte, 1, 0);                     \
-           insert_1_both ((char *) temp, print_buffer_pos,              \
-                          print_buffer_pos, 0, 1, 0);                   \
-           SAFE_FREE ();                                                \
-         }                                                              \
-       else                                                             \
-         insert_1_both (print_buffer, print_buffer_pos,                 \
-                        print_buffer_pos_byte, 0, 1, 0);                \
-       signal_after_change (PT - print_buffer_pos, 0, print_buffer_pos);\
-     }                                                                  \
-   if (MARKERP (original))                                              \
-     set_marker_both (original, Qnil, PT, PT_BYTE);                     \
-   if (old_point >= 0)                                                  \
-     SET_PT_BOTH (old_point + (old_point >= start_point                 \
-                               ? PT - start_point : 0),                 \
-                  old_point_byte + (old_point_byte >= start_point_byte  \
-                                    ? PT_BYTE - start_point_byte : 0)); \
-   unbind_to (specpdl_count, Qnil);                                     \
-
 /* This is used to free the print buffer; we don't simply record xfree
    since print_buffer can be reallocated during the printing.  */
-
 static void
 print_free_buffer (void)
 {
-  xfree (print_buffer);
-  print_buffer = NULL;
+  xfree (print_buffer.buffer);
+  print_buffer.buffer = NULL;
 }
 
 /* This is used to restore the saved contents of print_buffer
    when there is a recursive call to print.  */
-
 static void
 print_unwind (Lisp_Object saved_text)
 {
-  memcpy (print_buffer, SDATA (saved_text), SCHARS (saved_text));
+  memcpy (print_buffer.buffer, SDATA (saved_text), SCHARS (saved_text));
+}
+
+/* Lisp functions to do output using a stream must start with a call to
+   print_prepare, and end with calling print_finish.
+   Use printchar to output one character, or call strout to output a
+   block of characters.  */
+
+/* State carried between print_prepare and print_finish.  */
+struct print_context
+{
+  Lisp_Object printcharfun;
+  Lisp_Object old_printcharfun;
+  ptrdiff_t old_point, start_point;
+  ptrdiff_t old_point_byte, start_point_byte;
+  specpdl_ref specpdl_count;
+};
+
+static inline struct print_context
+print_prepare (Lisp_Object printcharfun)
+{
+  struct print_context pc = {
+    .old_printcharfun = printcharfun,
+    .old_point = -1,
+    .start_point = -1,
+    .old_point_byte = -1,
+    .start_point_byte = -1,
+    .specpdl_count = SPECPDL_INDEX (),
+  };
+  bool multibyte = !NILP (BVAR (current_buffer, enable_multibyte_characters));
+  record_unwind_current_buffer ();
+  specbind(Qprint__unreadable_callback_buffer, Fcurrent_buffer ());
+  if (NILP (printcharfun))
+    printcharfun = Qt;
+  if (BUFFERP (printcharfun))
+    {
+      if (XBUFFER (printcharfun) != current_buffer)
+        Fset_buffer (printcharfun);
+      printcharfun = Qnil;
+    }
+  if (MARKERP (printcharfun))
+    {
+      if (! XMARKER (printcharfun)->buffer)
+        error ("Marker does not point anywhere");
+      if (XMARKER (printcharfun)->buffer != current_buffer)
+        set_buffer_internal (XMARKER (printcharfun)->buffer);
+      ptrdiff_t marker_pos = marker_position (printcharfun);
+      if (marker_pos < BEGV || marker_pos > ZV)
+        signal_error ("Marker is outside the accessible part of the buffer",
+                      printcharfun);
+      pc.old_point = PT;
+      pc.old_point_byte = PT_BYTE;
+      SET_PT_BOTH (marker_pos, marker_byte_position (printcharfun));
+      pc.start_point = PT;
+      pc.start_point_byte = PT_BYTE;
+      printcharfun = Qnil;
+    }
+  if (NILP (printcharfun))
+    {
+      if (NILP (BVAR (current_buffer, enable_multibyte_characters))
+          && ! print_escape_multibyte)
+        specbind (Qprint_escape_multibyte, Qt);
+      if (! NILP (BVAR (current_buffer, enable_multibyte_characters))
+          && ! print_escape_nonascii)
+        specbind (Qprint_escape_nonascii, Qt);
+      if (print_buffer.buffer != NULL)
+        {
+          Lisp_Object string = make_string_from_bytes (print_buffer.buffer,
+                                                       print_buffer.pos,
+                                                       print_buffer.pos_byte);
+          record_unwind_protect (print_unwind, string);
+        }
+      else
+        {
+          int new_size = 1000;
+          print_buffer.buffer = xmalloc (new_size);
+          print_buffer.size = new_size;
+          record_unwind_protect_void (print_free_buffer);
+        }
+      print_buffer.pos = 0;
+      print_buffer.pos_byte = 0;
+    }
+  if (EQ (printcharfun, Qt) && ! noninteractive)
+    setup_echo_area_for_printing (multibyte);
+  pc.printcharfun = printcharfun;
+  return pc;
+}
+
+static inline void
+print_finish (struct print_context *pc)
+{
+  if (NILP (pc->printcharfun))
+    {
+      if (print_buffer.pos != print_buffer.pos_byte
+          && NILP (BVAR (current_buffer, enable_multibyte_characters)))
+        {
+          USE_SAFE_ALLOCA;
+          unsigned char *temp = SAFE_ALLOCA (print_buffer.pos + 1);
+          copy_text ((unsigned char *) print_buffer.buffer, temp,
+                     print_buffer.pos_byte, 1, 0);
+          insert_1_both ((char *) temp, print_buffer.pos,
+                         print_buffer.pos, 0, 1, 0);
+          SAFE_FREE ();
+        }
+      else
+        insert_1_both (print_buffer.buffer, print_buffer.pos,
+                       print_buffer.pos_byte, 0, 1, 0);
+      signal_after_change (PT - print_buffer.pos, 0, print_buffer.pos);
+    }
+  if (MARKERP (pc->old_printcharfun))
+    set_marker_both (pc->old_printcharfun, Qnil, PT, PT_BYTE);
+  if (pc->old_point >= 0)
+    SET_PT_BOTH (pc->old_point
+                 + (pc->old_point >= pc->start_point
+                    ? PT - pc->start_point : 0),
+                 pc->old_point_byte
+                 + (pc->old_point_byte >= pc->start_point_byte
+                    ? PT_BYTE - pc->start_point_byte : 0));
+  unbind_to (pc->specpdl_count, Qnil);
 }
 
 /* Print character CH to the stdio stream STREAM.  */
@@ -293,13 +312,14 @@ printchar (unsigned int ch, Lisp_Object fun)
 
       if (NILP (fun))
         {
-          ptrdiff_t incr = len - (print_buffer_size - print_buffer_pos_byte);
+          ptrdiff_t incr = len - (print_buffer.size - print_buffer.pos_byte);
           if (incr > 0)
-            print_buffer = xpalloc (print_buffer, &print_buffer_size,
-                                    incr, -1, 1);
-          memcpy (print_buffer + print_buffer_pos_byte, str, len);
-          print_buffer_pos += 1;
-          print_buffer_pos_byte += len;
+            print_buffer.buffer = xpalloc (print_buffer.buffer,
+                                           &print_buffer.size,
+                                           incr, -1, 1);
+          memcpy (print_buffer.buffer + print_buffer.pos_byte, str, len);
+          print_buffer.pos += 1;
+          print_buffer.pos_byte += len;
         }
       else if (noninteractive)
         {
@@ -358,12 +378,13 @@ strout (const char *ptr, ptrdiff_t size, ptrdiff_t size_byte,
 {
   if (NILP (printcharfun))
     {
-      ptrdiff_t incr = size_byte - (print_buffer_size - print_buffer_pos_byte);
+      ptrdiff_t incr = size_byte - (print_buffer.size - print_buffer.pos_byte);
       if (incr > 0)
-        print_buffer = xpalloc (print_buffer, &print_buffer_size, incr, -1, 1);
-      memcpy (print_buffer + print_buffer_pos_byte, ptr, size_byte);
-      print_buffer_pos += size;
-      print_buffer_pos_byte += size_byte;
+        print_buffer.buffer = xpalloc (print_buffer.buffer,
+                                       &print_buffer.size, incr, -1, 1);
+      memcpy (print_buffer.buffer + print_buffer.pos_byte, ptr, size_byte);
+      print_buffer.pos += size;
+      print_buffer.pos_byte += size_byte;
     }
   else if (noninteractive && EQ (printcharfun, Qt))
     {
@@ -527,14 +548,14 @@ PRINTCHARFUN defaults to the value of `standard-output' (which see).  */)
   if (NILP (printcharfun))
     printcharfun = Vstandard_output;
   CHECK_FIXNUM (character);
-  PRINTPREPARE;
-  printchar (XFIXNUM (character), printcharfun);
-  PRINTFINISH;
+  struct print_context pc = print_prepare (printcharfun);
+  printchar (XFIXNUM (character), pc.printcharfun);
+  print_finish (&pc);
   return character;
 }
 
 /* Print the contents of a unibyte C string STRING using PRINTCHARFUN.
-   The caller should arrange to put this inside PRINTPREPARE and PRINTFINISH.
+   The caller should arrange to put this inside print_prepare and print_finish.
    Do not use this on the contents of a Lisp string.  */
 
 static void
@@ -550,9 +571,9 @@ print_c_string (char const *string, Lisp_Object printcharfun)
 static void
 write_string (const char *data, Lisp_Object printcharfun)
 {
-  PRINTPREPARE;
-  print_c_string (data, printcharfun);
-  PRINTFINISH;
+  struct print_context pc = print_prepare (printcharfun);
+  print_c_string (data, pc.printcharfun);
+  print_finish (&pc);
 }
 
 
@@ -605,21 +626,21 @@ If PRINTCHARFUN is omitted or nil, the value of `standard-output' is used.  */)
 
   if (NILP (printcharfun))
     printcharfun = Vstandard_output;
-  PRINTPREPARE;
+  struct print_context pc = print_prepare (printcharfun);
 
   if (NILP (ensure))
     val = Qt;
   /* Difficult to check if at line beginning so abort.  */
-  else if (FUNCTIONP (printcharfun))
-    signal_error ("Unsupported function argument", printcharfun);
-  else if (noninteractive && !NILP (printcharfun))
+  else if (FUNCTIONP (pc.printcharfun))
+    signal_error ("Unsupported function argument", pc.printcharfun);
+  else if (noninteractive && !NILP (pc.printcharfun))
     val = printchar_stdout_last == 10 ? Qnil : Qt;
   else
     val = NILP (Fbolp ()) ? Qt : Qnil;
 
   if (!NILP (val))
-    printchar ('\n', printcharfun);
-  PRINTFINISH;
+    printchar ('\n', pc.printcharfun);
+  print_finish (&pc);
   return val;
 }
 
@@ -750,9 +771,9 @@ means "use default values for all the print-related settings".  */)
   if (!NILP (overrides))
     print_bind_overrides (overrides);
 
-  PRINTPREPARE;
-  print (object, printcharfun, 1);
-  PRINTFINISH;
+  struct print_context pc = print_prepare (printcharfun);
+  print (object, pc.printcharfun, 1);
+  print_finish (&pc);
 
   return unbind_to (count, object);
 }
@@ -787,11 +808,10 @@ A printed representation of an object is text which describes that object.  */)
      No need for specbind, since errors deactivate the mark.  */
   Lisp_Object save_deactivate_mark = Vdeactivate_mark;
 
-  Lisp_Object printcharfun = Vprin1_to_string_buffer;
-  PRINTPREPARE;
-  print (object, printcharfun, NILP (noescape));
-  /* Make Vprin1_to_string_buffer be the default buffer after PRINTFINISH */
-  PRINTFINISH;
+  struct print_context pc = print_prepare (Vprin1_to_string_buffer);
+  print (object, pc.printcharfun, NILP (noescape));
+  /* Make Vprin1_to_string_buffer be the default buffer after print_finish */
+  print_finish (&pc);
 
   struct buffer *previous = current_buffer;
   set_buffer_internal (XBUFFER (Vprin1_to_string_buffer));
@@ -836,15 +856,15 @@ is used instead.  */)
 {
   if (NILP (printcharfun))
     printcharfun = Vstandard_output;
-  PRINTPREPARE;
+  struct print_context pc = print_prepare (printcharfun);
   if (STRINGP (object)
       && !string_intervals (object)
       && NILP (Vprint_continuous_numbering))
     /* fast path for plain strings */
-    print_string (object, printcharfun);
+    print_string (object, pc.printcharfun);
   else
-    print (object, printcharfun, 0);
-  PRINTFINISH;
+    print (object, pc.printcharfun, 0);
+  print_finish (&pc);
   return object;
 }
 
@@ -875,11 +895,11 @@ is used instead.  */)
 {
   if (NILP (printcharfun))
     printcharfun = Vstandard_output;
-  PRINTPREPARE;
-  printchar ('\n', printcharfun);
-  print (object, printcharfun, 1);
-  printchar ('\n', printcharfun);
-  PRINTFINISH;
+  struct print_context pc = print_prepare (printcharfun);
+  printchar ('\n', pc.printcharfun);
+  print (object, pc.printcharfun, 1);
+  printchar ('\n', pc.printcharfun);
+  print_finish (&pc);
   return object;
 }
 
diff --git a/src/process.c b/src/process.c
index a15efa39bd1..23479c06194 100644
--- a/src/process.c
+++ b/src/process.c
@@ -1243,14 +1243,31 @@ or t (process is stopped).  */)
   return XPROCESS (process)->command;
 }
 
-DEFUN ("process-tty-name", Fprocess_tty_name, Sprocess_tty_name, 1, 1, 0,
+DEFUN ("process-tty-name", Fprocess_tty_name, Sprocess_tty_name, 1, 2, 0,
        doc: /* Return the name of the terminal PROCESS uses, or nil if none.
 This is the terminal that the process itself reads and writes on,
-not the name of the pty that Emacs uses to talk with that terminal.  */)
-  (register Lisp_Object process)
+not the name of the pty that Emacs uses to talk with that terminal.
+
+If STREAM is nil, return the terminal name if any of PROCESS's
+standard streams use a terminal for communication.  If STREAM is one
+of `stdin', `stdout', or `stderr', return the name of the terminal
+PROCESS uses for that stream specifically, or nil if that stream
+communicates via a pipe.  */)
+  (register Lisp_Object process, Lisp_Object stream)
 {
   CHECK_PROCESS (process);
-  return XPROCESS (process)->tty_name;
+  register struct Lisp_Process *p = XPROCESS (process);
+
+  if (NILP (stream))
+    return p->tty_name;
+  else if (EQ (stream, Qstdin))
+    return p->pty_in ? p->tty_name : Qnil;
+  else if (EQ (stream, Qstdout))
+    return p->pty_out ? p->tty_name : Qnil;
+  else if (EQ (stream, Qstderr))
+    return p->pty_out && NILP (p->stderrproc) ? p->tty_name : Qnil;
+  else
+    signal_error ("Unknown stream", stream);
 }
 
 static void
@@ -1316,6 +1333,19 @@ set_process_filter_masks (struct Lisp_Process *p)
     add_process_read_fd (p->infd);
 }
 
+static bool
+is_pty_from_symbol (Lisp_Object symbol)
+{
+  if (EQ (symbol, Qpty))
+    return true;
+  else if (EQ (symbol, Qpipe))
+    return false;
+  else if (NILP (symbol))
+    return !NILP (Vprocess_connection_type);
+  else
+    report_file_error ("Unknown connection type", symbol);
+}
+
 DEFUN ("set-process-filter", Fset_process_filter, Sset_process_filter,
        2, 2, 0,
        doc: /* Give PROCESS the filter function FILTER; nil means default.
@@ -1741,15 +1771,18 @@ signals to stop and continue a process.
 :connection-type TYPE -- TYPE is control type of device used to
 communicate with subprocesses.  Values are `pipe' to use a pipe, `pty'
 to use a pty, or nil to use the default specified through
-`process-connection-type'.
+`process-connection-type'.  If TYPE is a cons (INPUT . OUTPUT), then
+INPUT will be used for standard input and OUTPUT for standard output
+(and standard error if `:stderr' is nil).
 
 :filter FILTER -- Install FILTER as the process filter.
 
 :sentinel SENTINEL -- Install SENTINEL as the process sentinel.
 
 :stderr STDERR -- STDERR is either a buffer or a pipe process attached
-to the standard error of subprocess.  Specifying this implies
-`:connection-type' is set to `pipe'.  If STDERR is nil, standard error
+to the standard error of subprocess.  When specifying this, the
+subprocess's standard error will always communicate via a pipe, no
+matter the value of `:connection-type'.  If STDERR is nil, standard error
 is mixed with standard output and sent to BUFFER or FILTER.  (Note
 that specifying :stderr will create a new, separate (but associated)
 process, with its own filter and sentinel.  See
@@ -1845,22 +1878,20 @@ usage: (make-process &rest ARGS)  */)
   CHECK_TYPE (NILP (tem), Qnull, tem);
 
   tem = plist_get (contact, QCconnection_type);
-  if (EQ (tem, Qpty))
-    XPROCESS (proc)->pty_flag = true;
-  else if (EQ (tem, Qpipe))
-    XPROCESS (proc)->pty_flag = false;
-  else if (NILP (tem))
-    XPROCESS (proc)->pty_flag = !NILP (Vprocess_connection_type);
+  if (CONSP (tem))
+    {
+      XPROCESS (proc)->pty_in = is_pty_from_symbol (XCAR (tem));
+      XPROCESS (proc)->pty_out = is_pty_from_symbol (XCDR (tem));
+    }
   else
-    report_file_error ("Unknown connection type", tem);
-
-  if (!NILP (stderrproc))
     {
-      pset_stderrproc (XPROCESS (proc), stderrproc);
-
-      XPROCESS (proc)->pty_flag = false;
+      XPROCESS (proc)->pty_in = XPROCESS (proc)->pty_out =
+        is_pty_from_symbol (tem);
     }
 
+  if (!NILP (stderrproc))
+    pset_stderrproc (XPROCESS (proc), stderrproc);
+
 #ifdef HAVE_GNUTLS
   /* AKA GNUTLS_INITSTAGE(proc).  */
   verify (GNUTLS_STAGE_EMPTY == 0);
@@ -2099,66 +2130,80 @@ static void
 create_process (Lisp_Object process, char **new_argv, Lisp_Object current_dir)
 {
   struct Lisp_Process *p = XPROCESS (process);
-  int inchannel, outchannel;
+  int inchannel = -1, outchannel = -1;
   pid_t pid = -1;
   int vfork_errno;
   int forkin, forkout, forkerr = -1;
-  bool pty_flag = 0;
+  bool pty_in = false, pty_out = false;
   char pty_name[PTY_NAME_SIZE];
   Lisp_Object lisp_pty_name = Qnil;
+  int ptychannel = -1, pty_tty = -1;
   sigset_t oldset;
 
   /* Ensure that the SIGCHLD handler can notify
      `wait_reading_process_output'.  */
   child_signal_init ();
 
-  inchannel = outchannel = -1;
-
-  if (p->pty_flag)
-    outchannel = inchannel = allocate_pty (pty_name);
+  if (p->pty_in || p->pty_out)
+    ptychannel = allocate_pty (pty_name);
 
-  if (inchannel >= 0)
+  if (ptychannel >= 0)
     {
-      p->open_fd[READ_FROM_SUBPROCESS] = inchannel;
 #if ! defined (USG) || defined (USG_SUBTTY_WORKS)
       /* On most USG systems it does not work to open the pty's tty here,
          then close it and reopen it in the child.  */
       /* Don't let this terminal become our controlling terminal
          (in case we don't have one).  */
-      forkout = forkin = emacs_open (pty_name, O_RDWR | O_NOCTTY, 0);
-      if (forkin < 0)
+      pty_tty = emacs_open (pty_name, O_RDWR | O_NOCTTY, 0);
+      if (pty_tty < 0)
         report_file_error ("Opening pty", Qnil);
-      p->open_fd[SUBPROCESS_STDIN] = forkin;
-#else
-      forkin = forkout = -1;
 #endif /* not USG, or USG_SUBTTY_WORKS */
-      pty_flag = 1;
+      pty_in = p->pty_in;
+      pty_out = p->pty_out;
       lisp_pty_name = build_string (pty_name);
     }
+
+  /* Set up stdin for the child process.  */
+  if (ptychannel >= 0 && p->pty_in)
+    {
+      p->open_fd[SUBPROCESS_STDIN] = forkin = pty_tty;
+      outchannel = ptychannel;
+    }
   else
     {
-      if (emacs_pipe (p->open_fd + SUBPROCESS_STDIN) != 0
-          || emacs_pipe (p->open_fd + READ_FROM_SUBPROCESS) != 0)
+      if (emacs_pipe (p->open_fd + SUBPROCESS_STDIN) != 0)
         report_file_error ("Creating pipe", Qnil);
       forkin = p->open_fd[SUBPROCESS_STDIN];
       outchannel = p->open_fd[WRITE_TO_SUBPROCESS];
+    }
+
+  /* Set up stdout for the child process.  */
+  if (ptychannel >= 0 && p->pty_out)
+    {
+      forkout = pty_tty;
+      p->open_fd[READ_FROM_SUBPROCESS] = inchannel = ptychannel;
+    }
+  else
+    {
+      if (emacs_pipe (p->open_fd + READ_FROM_SUBPROCESS) != 0)
+        report_file_error ("Creating pipe", Qnil);
       inchannel = p->open_fd[READ_FROM_SUBPROCESS];
       forkout = p->open_fd[SUBPROCESS_STDOUT];
 
 #if defined(GNU_LINUX) && defined(F_SETPIPE_SZ)
       fcntl (inchannel, F_SETPIPE_SZ, read_process_output_max);
 #endif
+    }
 
-      if (!NILP (p->stderrproc))
-        {
-          struct Lisp_Process *pp = XPROCESS (p->stderrproc);
+  if (!NILP (p->stderrproc))
+    {
+      struct Lisp_Process *pp = XPROCESS (p->stderrproc);
 
-          forkerr = pp->open_fd[SUBPROCESS_STDOUT];
+      forkerr = pp->open_fd[SUBPROCESS_STDOUT];
 
-          /* Close unnecessary file descriptors.  */
-          close_process_fd (&pp->open_fd[WRITE_TO_SUBPROCESS]);
-          close_process_fd (&pp->open_fd[SUBPROCESS_STDIN]);
-        }
+      /* Close unnecessary file descriptors.  */
+      close_process_fd (&pp->open_fd[WRITE_TO_SUBPROCESS]);
+      close_process_fd (&pp->open_fd[SUBPROCESS_STDIN]);
     }
 
   if (FD_SETSIZE <= inchannel || FD_SETSIZE <= outchannel)
@@ -2183,7 +2228,8 @@ create_process (Lisp_Object process, char **new_argv, Lisp_Object current_dir)
      we just reopen the device (see emacs_get_tty_pgrp) as this is
      more portable (see USG_SUBTTY_WORKS above).  */
 
-  p->pty_flag = pty_flag;
+  p->pty_in = pty_in;
+  p->pty_out = pty_out;
   pset_status (p, Qrun);
 
   if (!EQ (p->command, Qt)
@@ -2199,13 +2245,15 @@ create_process (Lisp_Object process, char **new_argv, Lisp_Object current_dir)
   block_input ();
   block_child_signal (&oldset);
 
-  pty_flag = p->pty_flag;
-  eassert (pty_flag == ! NILP (lisp_pty_name));
+  pty_in = p->pty_in;
+  pty_out = p->pty_out;
+  eassert ((pty_in || pty_out) == ! NILP (lisp_pty_name));
 
   vfork_errno
     = emacs_spawn (&pid, forkin, forkout, forkerr, new_argv, env,
                    SSDATA (current_dir),
-                   pty_flag ? SSDATA (lisp_pty_name) : NULL, &oldset);
+                   pty_in || pty_out ? SSDATA (lisp_pty_name) : NULL,
+                   pty_in, pty_out, &oldset);
 
   eassert ((vfork_errno == 0) == (0 < pid));
 
@@ -2263,7 +2311,7 @@ create_pty (Lisp_Object process)
 {
   struct Lisp_Process *p = XPROCESS (process);
   char pty_name[PTY_NAME_SIZE];
-  int pty_fd = !p->pty_flag ? -1 : allocate_pty (pty_name);
+  int pty_fd = !(p->pty_in || p->pty_out) ? -1 : allocate_pty (pty_name);
 
   if (pty_fd >= 0)
     {
@@ -2301,7 +2349,7 @@ create_pty (Lisp_Object process)
          we just reopen the device (see emacs_get_tty_pgrp) as this is
          more portable (see USG_SUBTTY_WORKS above).  */
 
-      p->pty_flag = 1;
+      p->pty_in = p->pty_out = true;
       pset_status (p, Qrun);
       setup_process_coding_systems (process);
 
@@ -2412,7 +2460,7 @@ usage:  (make-pipe-process &rest ARGS)  */)
     p->kill_without_query = 1;
   if (tem = plist_get (contact, QCstop), !NILP (tem))
     pset_command (p, Qt);
-  eassert (! p->pty_flag);
+  eassert (! p->pty_in && ! p->pty_out);
 
   if (!EQ (p->command, Qt)
       && !EQ (p->filter, Qt))
@@ -3147,7 +3195,7 @@ usage:  (make-serial-process &rest ARGS)  */)
     p->kill_without_query = 1;
   if (tem = plist_get (contact, QCstop), !NILP (tem))
     pset_command (p, Qt);
-  eassert (! p->pty_flag);
+  eassert (! p->pty_in && ! p->pty_out);
 
   if (!EQ (p->command, Qt)
       && !EQ (p->filter, Qt))
@@ -6339,7 +6387,7 @@ Otherwise it discards the output.  */)
 
       /* If the restriction isn't what it should be, set it.  */
       if (old_begv != BEGV || old_zv != ZV)
-        Fnarrow_to_region (make_fixnum (old_begv), make_fixnum (old_zv), Qnil);
+        Fnarrow_to_region (make_fixnum (old_begv), make_fixnum (old_zv));
 
       bset_read_only (current_buffer, old_read_only);
       SET_PT_BOTH (opoint, opoint_byte);
@@ -6808,7 +6856,7 @@ process_send_signal (Lisp_Object process, int signo, Lisp_Object current_group,
     error ("Process %s is not active",
            SDATA (p->name));
 
-  if (!p->pty_flag)
+  if (! p->pty_in)
     current_group = Qnil;
 
   /* If we are using pgrps, get a pgrp number and make it negative.  */
@@ -7177,7 +7225,7 @@ process has been transmitted to the serial port.  */)
       send_process (proc, "", 0, Qnil);
     }
 
-  if (XPROCESS (proc)->pty_flag)
+  if (XPROCESS (proc)->pty_in)
     send_process (proc, "\004", 1, Qnil);
   else if (EQ (XPROCESS (proc)->type, Qserial))
     {
diff --git a/src/process.h b/src/process.h
index 392b661ce69..92baf0c4cb9 100644
--- a/src/process.h
+++ b/src/process.h
@@ -156,8 +156,9 @@ struct Lisp_Process
     /* True means kill silently if Emacs is exited.
        This is the inverse of the `query-on-exit' flag.  */
     bool_bf kill_without_query : 1;
-    /* True if communicating through a pty.  */
-    bool_bf pty_flag : 1;
+    /* True if communicating through a pty for input or output.  */
+    bool_bf pty_in : 1;
+    bool_bf pty_out : 1;
     /* Flag to set coding-system of the process buffer from the
        coding_system used to decode process output.  */
     bool_bf inherit_coding_system_flag : 1;
diff --git a/src/puresize.h b/src/puresize.h
index 5516747ac2b..4b746924bb1 100644
--- a/src/puresize.h
+++ b/src/puresize.h
@@ -47,7 +47,7 @@ INLINE_HEADER_BEGIN
 #endif
 
 #ifndef BASE_PURESIZE
-#define BASE_PURESIZE (2000000 + SYSTEM_PURESIZE_EXTRA + SITELOAD_PURESIZE_EXTRA)
+#define BASE_PURESIZE (2750000 + SYSTEM_PURESIZE_EXTRA + SITELOAD_PURESIZE_EXTRA)
 #endif
 
 /* Increase BASE_PURESIZE by a ratio depending on the machine's word size.  */
diff --git a/src/sysdep.c b/src/sysdep.c
index c1545622dfc..efd9638b07a 100644
--- a/src/sysdep.c
+++ b/src/sysdep.c
@@ -3169,7 +3169,8 @@ list_system_processes (void)
 
 #endif /* !defined (WINDOWSNT) */
 
-#if defined __FreeBSD__ || defined DARWIN_OS || defined __OpenBSD__
+#if (HAVE_GETRUSAGE \
+     || defined __FreeBSD__ || defined DARWIN_OS || defined __OpenBSD__)
 
 static Lisp_Object
 make_lisp_s_us (time_t s, long us)
@@ -4276,7 +4277,7 @@ does the same thing as `current-time'.  */)
       usecs -= 1000000;
       secs++;
     }
-  return make_lisp_time (make_timespec (secs, usecs * 1000));
+  return make_lisp_s_us (secs, usecs);
 #else /* ! HAVE_GETRUSAGE  */
 #ifdef WINDOWSNT
   return w32_get_internal_run_time ();
diff --git a/src/timefns.c b/src/timefns.c
index 9df50eaecc3..1112f174763 100644
--- a/src/timefns.c
+++ b/src/timefns.c
@@ -387,9 +387,9 @@ enum { flt_radix_power_size = DBL_MANT_DIG - DBL_MIN_EXP + 1 };
    equals FLT_RADIX**P.  */
 static Lisp_Object flt_radix_power;
 
-/* Convert T into an Emacs time *RESULT, truncating toward minus infinity.
-   Return zero if successful, an error number otherwise.  */
-static int
+/* Convert the finite number T into an Emacs time *RESULT, truncating
+   toward minus infinity.  Signal an error if unsuccessful.  */
+static void
 decode_float_time (double t, struct lisp_time *result)
 {
   Lisp_Object ticks, hz;
@@ -401,6 +401,7 @@ decode_float_time (double t, struct lisp_time *result)
   else
     {
       int scale = double_integer_scale (t);
+      eassume (scale < flt_radix_power_size);
 
       if (scale < 0)
         {
@@ -412,8 +413,6 @@ decode_float_time (double t, struct lisp_time *result)
             which is typically better than signaling overflow.  */
           scale = 0;
         }
-      else if (flt_radix_power_size <= scale)
-        return isnan (t) ? EDOM : EOVERFLOW;
 
       /* Compute TICKS, HZ such that TICKS / HZ exactly equals T, where HZ is
          T's frequency or 1, whichever is greater.  Here, “frequency” means
@@ -431,7 +430,6 @@ decode_float_time (double t, struct lisp_time *result)
     }
   result->ticks = ticks;
   result->hz = hz;
-  return 0;
 }
 
 /* Make a 4-element timestamp (HI LO US PS) from TICKS and HZ.
@@ -705,7 +703,7 @@ enum timeform
    TIMEFORM_TICKS_HZ /* fractional time: HI is ticks, LO is ticks per second */
   };
 
-/* From the valid form FORM and the time components HIGH, LOW, USEC
+/* From the non-float form FORM and the time components HIGH, LOW, USEC
    and PSEC, generate the corresponding time value.  If LOW is
    floating point, the other components should be zero and FORM should
    not be TIMEFORM_TICKS_HZ.
@@ -734,16 +732,7 @@ decode_time_components (enum timeform form,
       return EINVAL;
 
     case TIMEFORM_FLOAT:
-      {
-        double t = XFLOAT_DATA (low);
-        if (result)
-          return decode_float_time (t, result);
-        else
-          {
-            *dresult = t;
-            return 0;
-          }
-      }
+      eassume (false);
 
     case TIMEFORM_NIL:
       return decode_ticks_hz (timespec_ticks (current_timespec ()),
@@ -830,7 +819,16 @@ decode_lisp_time (Lisp_Object specified_time, bool decode_secs_only,
   if (NILP (specified_time))
     form = TIMEFORM_NIL;
   else if (FLOATP (specified_time))
-    form = TIMEFORM_FLOAT;
+    {
+      double d = XFLOAT_DATA (specified_time);
+      if (!isfinite (d))
+        time_error (isnan (d) ? EDOM : EOVERFLOW);
+      if (result)
+        decode_float_time (d, result);
+      else
+        *dresult = d;
+      return TIMEFORM_FLOAT;
+    }
   else if (CONSP (specified_time))
     {
       high = XCAR (specified_time);
@@ -878,7 +876,7 @@ decode_lisp_time (Lisp_Object specified_time, bool decode_secs_only,
   return form;
 }
 
-/* Convert a Lisp timestamp SPECIFIED_TIME to double.
+/* Convert a non-float Lisp timestamp SPECIFIED_TIME to double.
    Signal an error if unsuccessful.  */
 double
 float_time (Lisp_Object specified_time)
@@ -1074,27 +1072,9 @@ lispint_arith (Lisp_Object a, Lisp_Object b, bool subtract)
 static Lisp_Object
 time_arith (Lisp_Object a, Lisp_Object b, bool subtract)
 {
-  if (FLOATP (a) && !isfinite (XFLOAT_DATA (a)))
-    {
-      double da = XFLOAT_DATA (a);
-      double db = float_time (b);
-      return make_float (subtract ? da - db : da + db);
-    }
   enum timeform aform, bform;
   struct lisp_time ta = lisp_time_struct (a, &aform);
-
-  if (FLOATP (b) && !isfinite (XFLOAT_DATA (b)))
-    return subtract ? make_float (-XFLOAT_DATA (b)) : b;
-
-  /* Subtract nil from nil correctly, and handle other eq values
-     quicker while we're at it.  Compare here rather than earlier, to
-     handle NaNs and check formats.  */
-  struct lisp_time tb;
-  if (BASE_EQ (a, b))
-    bform = aform, tb = ta;
-  else
-    tb = lisp_time_struct (b, &bform);
-
+  struct lisp_time tb = lisp_time_struct (b, &bform);
   Lisp_Object ticks, hz;
 
   if (FASTER_TIMEFNS && BASE_EQ (ta.hz, tb.hz))
@@ -1201,30 +1181,32 @@ See `format-time-string' for the various forms of a time value.
 For example, nil stands for the current time.  */)
   (Lisp_Object a, Lisp_Object b)
 {
+  /* Subtract nil from nil correctly, and handle other eq values
+     quicker while we're at it.  This means (time-subtract X X) does
+     not signal an error if X is not a valid time value, but that's OK.  */
+  if (BASE_EQ (a, b))
+    return timespec_to_lisp ((struct timespec) {0});
+
   return time_arith (a, b, true);
 }
 
-/* Return negative, 0, positive if a < b, a == b, a > b respectively.
-   Return positive if either a or b is a NaN; this is good enough
-   for the current callers.  */
-static int
+/* Return negative, 0, positive if A < B, A == B, A > B respectively.
+   A and B should be Lisp time values.  */
+static EMACS_INT
 time_cmp (Lisp_Object a, Lisp_Object b)
 {
-  if ((FLOATP (a) && !isfinite (XFLOAT_DATA (a)))
-      || (FLOATP (b) && !isfinite (XFLOAT_DATA (b))))
-    {
-      double da = FLOATP (a) ? XFLOAT_DATA (a) : 0;
-      double db = FLOATP (b) ? XFLOAT_DATA (b) : 0;
-      return da < db ? -1 : da != db;
-    }
-
   /* Compare nil to nil correctly, and handle other eq values quicker
-     while we're at it.  Compare here rather than earlier, to handle
-     NaNs.  This means (time-equal-p X X) does not signal an error if
-     X is not a valid time value, but that's OK.  */
+     while we're at it.  This means (time-equal-p X X) does not signal
+     an error if X is not a valid time value, but that's OK.  */
   if (BASE_EQ (a, b))
     return 0;
 
+  /* Compare (X . Z) to (Y . Z) quickly if X and Y are fixnums.
+     Do not inspect Z, as it is OK to not signal if A and B are invalid.  */
+  if (FASTER_TIMEFNS && CONSP (a) && CONSP (b) && BASE_EQ (XCDR (a), XCDR (b))
+      && FIXNUMP (XCAR (a)) && FIXNUMP (XCAR (b)))
+    return XFIXNUM (XCAR (a)) - XFIXNUM (XCAR (b));
+
   /* Compare (ATICKS . AZ) to (BTICKS . BHZ) by comparing
      ATICKS * BHZ to BTICKS * AHZ.  */
   struct lisp_time ta = lisp_time_struct (a, 0);
@@ -1258,7 +1240,9 @@ DEFUN ("time-equal-p", Ftime_equal_p, Stime_equal_p, 2, 2, 0,
 See `format-time-string' for the various forms of a time value.  */)
   (Lisp_Object a, Lisp_Object b)
 {
-  return time_cmp (a, b) == 0 ? Qt : Qnil;
+  /* A nil arg compares unequal to a non-nil arg.  This also saves the
+     expense of current_timespec if either arg is nil.  */
+  return NILP (a) == NILP (b) && time_cmp (a, b) == 0 ? Qt : Qnil;
 }
 
 
@@ -1269,11 +1253,12 @@ instead of the current time.  See `format-time-string' for the various
 forms of a time value.
 
 WARNING: Since the result is floating point, it may not be exact.
-If precise time stamps are required, use either `encode-time',
+If precise time stamps are required, use either `time-convert',
 or (if you need time as a string) `format-time-string'.  */)
   (Lisp_Object specified_time)
 {
-  return make_float (float_time (specified_time));
+  return (FLOATP (specified_time) ? specified_time
+          : make_float (float_time (specified_time)));
 }
 
 /* Write information into buffer S of size MAXSIZE, according to the
diff --git a/src/w32fns.c b/src/w32fns.c
index 5e42a1df6ff..28d13a68d45 100644
--- a/src/w32fns.c
+++ b/src/w32fns.c
@@ -10508,6 +10508,7 @@ frame_parm_handler w32_frame_parm_handlers[] =
   0, /* x_set_override_redirect */
   gui_set_no_special_glyphs,
   gui_set_alpha_background,
+  0, /* x_set_use_frame_synchronization */
 };
 
 void
diff --git a/src/xdisp.c b/src/xdisp.c
index 88a489e290f..5268c359ecd 100644
--- a/src/xdisp.c
+++ b/src/xdisp.c
@@ -3229,6 +3229,7 @@ init_iterator (struct it *it, struct window *w,
   it->f = XFRAME (w->frame);
 
   it->cmp_it.id = -1;
+  it->cmp_it.parent_it = it;
 
   if (max_redisplay_ticks > 0)
     update_redisplay_ticks (0, w);
@@ -3413,12 +3414,6 @@ init_iterator (struct it *it, struct window *w,
         }
     }
 
-  if (current_buffer->long_line_optimizations_p)
-    {
-      it->narrowed_begv = get_narrowed_begv (w, window_point (w));
-      it->narrowed_zv = get_narrowed_zv (w, window_point (w));
-    }
-
   /* If a buffer position was specified, set the iterator there,
      getting overlays and face properties from that position.  */
   if (charpos >= BUF_BEG (current_buffer))
@@ -3478,6 +3473,10 @@ init_iterator (struct it *it, struct window *w,
                         &it->bidi_it);
         }
 
+      /* This is set only when long_line_optimizations_p is non-zero
+         for the current buffer.  */
+      it->narrowed_begv = 0;
+
       /* Compute faces etc.  */
       reseat (it, it->current.pos, true);
     }
@@ -3510,9 +3509,7 @@ ptrdiff_t
 get_narrowed_begv (struct window *w, ptrdiff_t pos)
 {
   int len = get_narrowed_len (w);
-  ptrdiff_t begv;
-  begv = max ((pos / len - 1) * len, BEGV);
-  return begv == BEGV ? 0 : begv;
+  return max ((pos / len - 1) * len, BEGV);
 }
 
 ptrdiff_t
@@ -4397,16 +4394,16 @@ handle_fontified_prop (struct it *it)
 
       if (current_buffer->long_line_optimizations_p)
         {
-          ptrdiff_t begv = it->narrowed_begv ? it->narrowed_begv : BEGV;
+          ptrdiff_t begv = it->narrowed_begv;
           ptrdiff_t zv = it->narrowed_zv;
           ptrdiff_t charpos = IT_CHARPOS (*it);
           if (charpos < begv || charpos > zv)
             {
               begv = get_narrowed_begv (it->w, charpos);
-              if (!begv) begv = BEGV;
               zv = get_narrowed_zv (it->w, charpos);
             }
-          Fnarrow_to_region (make_fixnum (begv), make_fixnum (zv), Qt);
+          narrow_to_region_internal (make_fixnum (begv), make_fixnum (zv), true);
+          specbind (Qrestrictions_locked, Qt);
         }
 
       /* Don't allow Lisp that runs from 'fontification-functions'
@@ -7416,7 +7413,7 @@ back_to_previous_visible_line_start (struct it *it)
   it->continuation_lines_width = 0;
 
   eassert (IT_CHARPOS (*it) >= BEGV);
-  eassert (it->narrowed_begv > BEGV
+  eassert (it->narrowed_begv > 0 /* long-line optimizations: all bets off */
            || IT_CHARPOS (*it) == BEGV
            || FETCH_BYTE (IT_BYTEPOS (*it) - 1) == '\n');
   CHECK_IT (it);
@@ -7532,6 +7529,21 @@ reseat (struct it *it, struct text_pos pos, bool force_p)
 
   reseat_1 (it, pos, false);
 
+  if (current_buffer->long_line_optimizations_p)
+    {
+      if (!it->narrowed_begv)
+        {
+          it->narrowed_begv = get_narrowed_begv (it->w, window_point (it->w));
+          it->narrowed_zv = get_narrowed_zv (it->w, window_point (it->w));
+        }
+      else if ((pos.charpos < it->narrowed_begv || pos.charpos > it->narrowed_zv)
+                && (!redisplaying_p || it->line_wrap == TRUNCATE))
+        {
+          it->narrowed_begv = get_narrowed_begv (it->w, pos.charpos);
+          it->narrowed_zv = get_narrowed_zv (it->w, pos.charpos);
+        }
+    }
+
   /* Determine where to check text properties.  Avoid doing it
      where possible because text property lookup is very expensive.  */
   if (force_p
@@ -8837,7 +8849,7 @@ get_visually_first_element (struct it *it)
 
   SET_WITH_NARROWED_BEGV (it, bob,
                           string_p ? 0 :
-                          IT_BYTEPOS (*it) < BEGV ? obegv : BEGV,
+                          IT_CHARPOS (*it) < BEGV ? obegv : BEGV,
                           it->narrowed_begv);
 
   if (STRINGP (it->string))
@@ -10699,6 +10711,11 @@ move_it_vertically_backward (struct it *it, int dy)
   while (nlines-- && IT_CHARPOS (*it) > pos_limit)
     back_to_previous_visible_line_start (it);
 
+  /* Move one line more back, for the (rare) situation where we have
+     bidi-reordered continued lines, and we start from the top-most
+     screen line, which is the last in logical order.  */
+  if (it->bidi_p && dy == 0)
+    back_to_previous_visible_line_start (it);
   /* Reseat the iterator here.  When moving backward, we don't want
      reseat to skip forward over invisible text, set up the iterator
      to deliver from overlay strings at the new position etc.  So,
@@ -10772,7 +10789,7 @@ move_it_vertically_backward (struct it *it, int dy)
           dec_both (&cp, &bp);
           SET_WITH_NARROWED_BEGV (it, cp,
                                   find_newline_no_quit (cp, bp, -1, NULL),
-                                  it->narrowed_begv);
+                                  get_closer_narrowed_begv (it->w, IT_CHARPOS (*it)));
           move_it_to (it, cp, -1, -1, -1, MOVE_TO_POS);
         }
       bidi_unshelve_cache (it3data, true);
@@ -10950,6 +10967,7 @@ move_it_by_lines (struct it *it, ptrdiff_t dvpos)
          position.  This may actually move vertically backwards,
          in case of overlays, so adjust dvpos accordingly.  */
       dvpos += it->vpos;
+      start_charpos = IT_CHARPOS (*it);
       move_it_vertically_backward (it, 0);
       dvpos -= it->vpos;
 
@@ -11003,7 +11021,7 @@ move_it_by_lines (struct it *it, ptrdiff_t dvpos)
           SAVE_IT (it2, *it, it2data);
           move_it_to (it, -1, -1, -1, it->vpos + delta, MOVE_TO_VPOS);
           /* Move back again if we got too far ahead.  */
-          if (IT_CHARPOS (*it) >= start_charpos)
+          if (it->vpos - it2.vpos > delta)
             RESTORE_IT (it, &it2, it2data);
           else
             bidi_unshelve_cache (it2data, true);
@@ -18115,8 +18133,8 @@ run_window_scroll_functions (Lisp_Object window, struct text_pos startp)
     {
       specpdl_ref count = SPECPDL_INDEX ();
       specbind (Qinhibit_quit, Qt);
-      run_hook_with_args_2 (Qwindow_scroll_functions, window,
-                            make_fixnum (CHARPOS (startp)));
+      safe_run_hooks_2
+        (Qwindow_scroll_functions, window, make_fixnum (CHARPOS (startp)));
       unbind_to (count, Qnil);
       SET_TEXT_POS_FROM_MARKER (startp, w->start);
       /* In case the hook functions switch buffers.  */
@@ -18825,6 +18843,8 @@ try_cursor_movement (Lisp_Object window, struct text_pos startp,
             {
               /* Cursor has to be moved backward.  Note that PT >=
                  CHARPOS (startp) because of the outer if-statement.  */
+              struct glyph_row *row0 = row;
+
               while (!row->mode_line_p
                      && (MATRIX_ROW_START_CHARPOS (row) > PT
                          || (MATRIX_ROW_START_CHARPOS (row) == PT
@@ -18839,6 +18859,23 @@ try_cursor_movement (Lisp_Object window, struct text_pos startp,
                   --row;
                 }
 
+              /* With bidi-reordered rows we can have buffer positions
+                 _decrease_ when going down by rows.  If we haven't
+                 found our row in the loop above, give it another try
+                 now going in the other direction from the original row.  */
+              if (!(MATRIX_ROW_START_CHARPOS (row) <= PT
+                    && PT <= MATRIX_ROW_END_CHARPOS (row))
+                  && row0->continued_p)
+                {
+                  row = row0;
+                  while (MATRIX_ROW_START_CHARPOS (row) > PT
+                         && MATRIX_ROW_BOTTOM_Y (row) < last_y)
+                    {
+                      eassert (row->enabled_p);
+                      ++row;
+                    }
+                }
+
               /* Consider the following case: Window starts at BEGV,
                  there is invisible, intangible text at BEGV, so that
                  display starts at some point START > BEGV.  It can
@@ -18862,9 +18899,16 @@ try_cursor_movement (Lisp_Object window, struct text_pos startp,
                      && !cursor_row_p (row))
                 ++row;
 
-              /* If within the scroll margin, scroll.  */
-              if (row->y < top_scroll_margin
-                  && CHARPOS (startp) != BEGV)
+              /* If within the scroll margin, either the top one or
+                 the bottom one, scroll.  */
+              if ((row->y < top_scroll_margin
+                   && CHARPOS (startp) != BEGV)
+                  || MATRIX_ROW_BOTTOM_Y (row) > last_y
+                  || PT > MATRIX_ROW_END_CHARPOS (row)
+                  || (MATRIX_ROW_BOTTOM_Y (row) == last_y
+                      && PT == MATRIX_ROW_END_CHARPOS (row)
+                      && !row->ends_at_zv_p
+                      && !MATRIX_ROW_ENDS_IN_MIDDLE_OF_CHAR_P (row)))
                 scroll_p = true;
             }
           else
@@ -19448,7 +19492,7 @@ redisplay_window (Lisp_Object window, bool just_this_one_p)
     {
       ptrdiff_t cur, next, found, max = 0, threshold;
       threshold = XFIXNUM (Vlong_line_threshold);
-      for (cur = 1; cur < Z; cur = next)
+      for (cur = BEG; cur < Z; cur = next)
         {
           next = find_newline1 (cur, CHAR_TO_BYTE (cur), 0, -1, 1,
                                 &found, NULL, true);
diff --git a/src/xfns.c b/src/xfns.c
index 1ae615fad44..2845ecca6a9 100644
--- a/src/xfns.c
+++ b/src/xfns.c
@@ -609,24 +609,24 @@ x_relative_mouse_position (struct frame *f, int *x, int *y)
 
   block_input ();
 
-  XQueryPointer (FRAME_X_DISPLAY (f),
-                 FRAME_DISPLAY_INFO (f)->root_window,
+  x_query_pointer (FRAME_X_DISPLAY (f),
+                   FRAME_DISPLAY_INFO (f)->root_window,
 
-                 /* The root window which contains the pointer.  */
-                 &root,
+                   /* The root window which contains the pointer.  */
+                   &root,
 
-                 /* Window pointer is on, not used  */
-                 &dummy_window,
+                   /* Window pointer is on, not used  */
+                   &dummy_window,
 
-                 /* The position on that root window.  */
-                 x, y,
+                   /* The position on that root window.  */
+                   x, y,
 
-                 /* x/y in dummy_window coordinates, not used.  */
-                 &dummy, &dummy,
+                   /* x/y in dummy_window coordinates, not used.  */
+                   &dummy, &dummy,
 
-                 /* Modifier keys and pointer buttons, about which
-                    we don't care.  */
-                 (unsigned int *) &dummy);
+                   /* Modifier keys and pointer buttons, about which
+                      we don't care.  */
+                   (unsigned int *) &dummy);
 
   XTranslateCoordinates (FRAME_X_DISPLAY (f),
 
@@ -1202,20 +1202,6 @@ x_set_background_color (struct frame *f, Lisp_Object arg, Lisp_Object oldval)
       xg_set_background_color (f, bg);
 #endif
 
-#ifndef USE_TOOLKIT_SCROLL_BARS /* Turns out to be annoying with
-                                   toolkit scroll bars.  */
-      {
-        Lisp_Object bar;
-        for (bar = FRAME_SCROLL_BARS (f);
-             !NILP (bar);
-             bar = XSCROLL_BAR (bar)->next)
-          {
-            Window window = XSCROLL_BAR (bar)->x_window;
-            XSetWindowBackground (dpy, window, bg);
-          }
-      }
-#endif /* USE_TOOLKIT_SCROLL_BARS */
-
       unblock_input ();
       update_face_from_frame_parameter (f, Qbackground_color, arg);
 
@@ -2431,6 +2417,28 @@ x_set_alpha (struct frame *f, Lisp_Object arg, Lisp_Object oldval)
     }
 }
 
+static void
+x_set_use_frame_synchronization (struct frame *f, Lisp_Object arg,
+                                 Lisp_Object oldval)
+{
+#if !defined USE_GTK && defined HAVE_XSYNC
+  struct x_display_info *dpyinfo;
+
+  dpyinfo = FRAME_DISPLAY_INFO (f);
+
+  if (!NILP (arg) && FRAME_X_EXTENDED_COUNTER (f))
+    FRAME_X_OUTPUT (f)->use_vsync_p
+      = x_wm_supports (f, dpyinfo->Xatom_net_wm_frame_drawn);
+  else
+    FRAME_X_OUTPUT (f)->use_vsync_p = false;
+
+  store_frame_param (f, Quse_frame_synchronization,
+                     FRAME_X_OUTPUT (f)->use_vsync_p ? Qt : Qnil);
+#else
+  store_frame_param (f, Quse_frame_synchronization, Qnil);
+#endif
+}
+
 
 /* Record in frame F the specified or default value according to ALIST
    of the parameter named PROP (a Lisp symbol).  If no value is
@@ -5149,18 +5157,20 @@ This function is an internal primitive--use `make-frame' instead.  */)
                        (unsigned char *) &counters,
                        ((STRINGP (value)
                          && !strcmp (SSDATA (value), "extended")) ? 2 : 1));
-#endif
 
-#ifndef USE_GTK
-      if (FRAME_X_EXTENDED_COUNTER (f))
-        FRAME_X_OUTPUT (f)->use_vsync_p
-          = x_wm_supports (f, dpyinfo->Xatom_net_wm_frame_drawn);
+#if defined HAVE_XSYNCTRIGGERFENCE && !defined USE_GTK
+      x_sync_init_fences (f);
+#endif
 #endif
     }
 #endif
 
   unblock_input ();
 
+  /* Set whether or not frame synchronization is enabled.  */
+  gui_default_parameter (f, parms, Quse_frame_synchronization, Qt,
+                         NULL, NULL, RES_TYPE_BOOLEAN);
+
   /* Works iff frame has been already mapped.  */
   gui_default_parameter (f, parms, Qskip_taskbar, Qnil,
                          NULL, NULL, RES_TYPE_BOOLEAN);
@@ -6813,10 +6823,10 @@ selected frame's display.  */)
     return Qnil;
 
   block_input ();
-  XQueryPointer (FRAME_X_DISPLAY (f),
-                 FRAME_DISPLAY_INFO (f)->root_window,
-                 &root, &dummy_window, &x, &y, &dummy, &dummy,
-                 (unsigned int *) &dummy);
+  x_query_pointer (FRAME_X_DISPLAY (f),
+                   FRAME_DISPLAY_INFO (f)->root_window,
+                   &root, &dummy_window, &x, &y, &dummy, &dummy,
+                   (unsigned int *) &dummy);
   unblock_input ();
 
   return Fcons (make_fixnum (x), make_fixnum (y));
@@ -8372,8 +8382,8 @@ compute_tip_xy (struct frame *f, Lisp_Object parms, Lisp_Object dx,
       Lisp_Object frame, attributes, monitor, geometry;
 
       block_input ();
-      XQueryPointer (FRAME_X_DISPLAY (f), FRAME_DISPLAY_INFO (f)->root_window,
-                     &root, &child, root_x, root_y, &win_x, &win_y, &pmask);
+      x_query_pointer (FRAME_X_DISPLAY (f), FRAME_DISPLAY_INFO (f)->root_window,
+                       &root, &child, root_x, root_y, &win_x, &win_y, &pmask);
       unblock_input ();
 
       XSETFRAME (frame, f);
@@ -9775,6 +9785,7 @@ frame_parm_handler x_frame_parm_handlers[] =
   x_set_override_redirect,
   gui_set_no_special_glyphs,
   x_set_alpha_background,
+  x_set_use_frame_synchronization,
   x_set_shaded,
 };
 
diff --git a/src/xmenu.c b/src/xmenu.c
index 3be0fb18766..5b8a8f77a2d 100644
--- a/src/xmenu.c
+++ b/src/xmenu.c
@@ -232,6 +232,7 @@ static void
 x_menu_translate_generic_event (XEvent *event)
 {
   struct x_display_info *dpyinfo;
+  struct xi_device_t *device;
   XEvent copy;
   XIDeviceEvent *xev;
 
@@ -265,6 +266,16 @@ x_menu_translate_generic_event (XEvent *event)
               copy.xbutton.button = xev->detail;
               copy.xbutton.same_screen = True;
 
+              device = xi_device_from_id (dpyinfo, xev->deviceid);
+
+              /* I don't know the repercussions of changing
+                 device->grab on XI_ButtonPress events, so be safe and
+                 only do what is necessary to prevent the grab from
+                 being left invalid as XMenuActivate swallows
+                 events.  */
+              if (device && xev->evtype == XI_ButtonRelease)
+                device->grab &= ~(1 << xev->detail);
+
               XPutBackEvent (dpyinfo->display, &copy);
 
               break;
@@ -2507,6 +2518,10 @@ pop_down_menu (void *arg)
   struct pop_down_menu *data = arg;
   struct frame *f = data->frame;
   XMenu *menu = data->menu;
+#ifdef HAVE_XINPUT2
+  int i;
+  struct xi_device_t *device;
+#endif
 
   block_input ();
 #ifndef MSDOS
@@ -2526,6 +2541,17 @@ pop_down_menu (void *arg)
      results, and it is a pain to ask which are actually held now.  */
   FRAME_DISPLAY_INFO (f)->grabbed = 0;
 
+#ifdef HAVE_XINPUT2
+  /* Likewise for XI grabs when the mouse is released on top of the
+     menu itself.  */
+
+  for (i = 0; i < FRAME_DISPLAY_INFO (f)->num_devices; ++i)
+    {
+      device = &FRAME_DISPLAY_INFO (f)->devices[i];
+      device->grab = 0;
+    }
+#endif
+
 #endif /* HAVE_X_WINDOWS */
 
   unblock_input ();
diff --git a/src/xsettings.c b/src/xsettings.c
index c29a844e0a8..9c60ff825a4 100644
--- a/src/xsettings.c
+++ b/src/xsettings.c
@@ -964,9 +964,10 @@ read_and_apply_settings (Display_Info *dpyinfo, bool send_event_p)
 #endif
 
 #ifndef HAVE_PGTK
-/* Check if EVENT for the display in DPYINFO is XSettings related.  */
+/* Check if EVENT for the display in DPYINFO is XSettings related.
+   Return true if it is, after performing associated side effects.  */
 
-void
+bool
 xft_settings_event (Display_Info *dpyinfo, const XEvent *event)
 {
   bool check_window_p = false, apply_settings_p = false;
@@ -1004,6 +1005,8 @@ xft_settings_event (Display_Info *dpyinfo, const XEvent *event)
 
   if (apply_settings_p)
     read_and_apply_settings (dpyinfo, true);
+
+  return check_window_p || apply_settings_p;
 }
 #endif
 
diff --git a/src/xsettings.h b/src/xsettings.h
index 5e5df37062b..833c2b367dc 100644
--- a/src/xsettings.h
+++ b/src/xsettings.h
@@ -36,7 +36,7 @@ typedef struct pgtk_display_info Display_Info;
 
 extern void xsettings_initialize (Display_Info *);
 #ifndef HAVE_PGTK
-extern void xft_settings_event (Display_Info *, const XEvent *);
+extern bool xft_settings_event (Display_Info *, const XEvent *);
 #endif
 extern const char *xsettings_get_system_font (void);
 #ifdef USE_LUCID
diff --git a/src/xterm.c b/src/xterm.c
index d7d4cb418f3..48f10269dfc 100644
--- a/src/xterm.c
+++ b/src/xterm.c
@@ -997,6 +997,7 @@ static const struct x_atom_ref x_atom_refs[] =
     ATOM_REFS_INIT ("_NET_WORKAREA", Xatom_net_workarea)
     ATOM_REFS_INIT ("_NET_WM_SYNC_REQUEST", Xatom_net_wm_sync_request)
     ATOM_REFS_INIT ("_NET_WM_SYNC_REQUEST_COUNTER", Xatom_net_wm_sync_request_counter)
+    ATOM_REFS_INIT ("_NET_WM_SYNC_FENCES", Xatom_net_wm_sync_fences)
     ATOM_REFS_INIT ("_NET_WM_FRAME_DRAWN", Xatom_net_wm_frame_drawn)
     ATOM_REFS_INIT ("_NET_WM_FRAME_TIMINGS", Xatom_net_wm_frame_timings)
     ATOM_REFS_INIT ("_NET_WM_USER_TIME", Xatom_net_wm_user_time)
@@ -2837,8 +2838,8 @@ x_dnd_free_toplevels (bool display_alive)
   struct x_client_list_window *last;
   struct x_client_list_window *tem = x_dnd_toplevels;
   ptrdiff_t n_windows, i, buffer_size;
-  Window *destroy_windows;
-  unsigned long *prev_masks;
+  Window *destroy_windows UNINIT;
+  unsigned long *prev_masks UNINIT;
   specpdl_ref count;
   Display *dpy;
   struct x_display_info *dpyinfo;
@@ -2847,10 +2848,6 @@ x_dnd_free_toplevels (bool display_alive)
     /* Probably called inside an IO error handler.  */
     return;
 
-  /* Pacify GCC.  */
-  prev_masks = NULL;
-  destroy_windows = NULL;
-
   if (display_alive)
     {
       buffer_size = 1024;
@@ -2913,6 +2910,7 @@ x_dnd_free_toplevels (bool display_alive)
 
       if (n_windows)
         {
+          eassume (dpyinfo);
           x_ignore_errors_for_next_request (dpyinfo);
 
           for (i = 0; i < n_windows; ++i)
@@ -4963,15 +4961,6 @@ x_xr_ensure_picture (struct frame *f)
 }
 #endif
 
-/* Remove calls to XFlush by defining XFlush to an empty replacement.
-   Calls to XFlush should be unnecessary because the X output buffer
-   is flushed automatically as needed by calls to XPending,
-   XNextEvent, or XWindowEvent according to the XFlush man page.
-   XTread_socket calls XPending.  Removing XFlush improves
-   performance.  */
-
-#define XFlush(DISPLAY) (void) 0
-
 
 /***********************************************************************
                               Debugging
@@ -5293,15 +5282,15 @@ xi_populate_device_from_info (struct xi_device_t *xi_device,
                                   * device->num_classes);
   values = NULL;
 #endif
-#ifdef HAVE_XINPUT2_2
-  xi_device->touchpoints = NULL;
-#endif
 
   xi_device->use = device->use;
+  xi_device->name = build_string (device->name);
+  xi_device->attachment = device->attachment;
+
 #ifdef HAVE_XINPUT2_2
+  xi_device->touchpoints = NULL;
   xi_device->direct_p = false;
 #endif
-  xi_device->name = build_string (device->name);
 
   for (c = 0; c < device->num_classes; ++c)
     {
@@ -5405,7 +5394,7 @@ xi_populate_device_from_info (struct xi_device_t *xi_device,
 static void
 x_cache_xi_devices (struct x_display_info *dpyinfo)
 {
-  int ndevices, actual_devices;
+  int ndevices, actual_devices, i;
   XIDeviceInfo *infos;
 
   actual_devices = 0;
@@ -5422,9 +5411,9 @@ x_cache_xi_devices (struct x_display_info *dpyinfo)
       return;
     }
 
-  dpyinfo->devices = xmalloc (sizeof *dpyinfo->devices * ndevices);
+  dpyinfo->devices = xzalloc (sizeof *dpyinfo->devices * ndevices);
 
-  for (int i = 0; i < ndevices; ++i)
+  for (i = 0; i < ndevices; ++i)
     {
       if (infos[i].enabled)
         xi_populate_device_from_info (&dpyinfo->devices[actual_devices++],
@@ -6617,12 +6606,17 @@ x_if_event (Display *dpy, XEvent *event_return,
   current_time = current_timespec ();
   target = timespec_add (current_time, timeout);
 
+  /* Check if an event is already in the queue.  If it is, avoid
+     syncing.  */
+  if (XCheckIfEvent (dpy, event_return, predicate, arg))
+    return 0;
+
   while (true)
     {
       /* Get events into the queue.  */
       XSync (dpy, False);
 
-      /* Check if an event is now in the queue.  */
+      /* Look for an event again.  */
       if (XCheckIfEvent (dpy, event_return, predicate, arg))
         return 0;
 
@@ -6646,6 +6640,61 @@ x_if_event (Display *dpy, XEvent *event_return,
     }
 }
 
+/* Return the monotonic time corresponding to the high-resolution
+   server timestamp TIMESTAMP.  Return 0 if the necessary information
+   is not available.  */
+
+static uint64_t
+x_sync_get_monotonic_time (struct x_display_info *dpyinfo,
+                           uint64_t timestamp)
+{
+  if (dpyinfo->server_time_monotonic_p)
+    return timestamp;
+
+  /* This means we haven't yet initialized the server time offset.  */
+  if (!dpyinfo->server_time_offset)
+    return 0;
+
+  return timestamp - dpyinfo->server_time_offset;
+}
+
+/* Return the current monotonic time in the same format as a
+   high-resolution server timestamp.  */
+
+static uint64_t
+x_sync_current_monotonic_time (void)
+{
+  struct timespec time;
+
+  clock_gettime (CLOCK_MONOTONIC, &time);
+  return time.tv_sec * 1000000 + time.tv_nsec / 1000;
+}
+
+/* Decode a _NET_WM_FRAME_DRAWN message and calculate the time it took
+   to draw the last frame.  */
+
+static void
+x_sync_note_frame_times (struct x_display_info *dpyinfo,
+                         struct frame *f, XEvent *event)
+{
+  uint64_t low, high, time;
+  struct x_output *output;
+
+  low = event->xclient.data.l[2];
+  high = event->xclient.data.l[3];
+  output = FRAME_X_OUTPUT (f);
+
+  time = x_sync_get_monotonic_time (dpyinfo, low | (high << 32));
+
+  if (time)
+    output->last_frame_time = time - output->temp_frame_time;
+
+#ifdef FRAME_DEBUG
+  fprintf (stderr, "Drawing the last frame took: %lu ms (%lu)\n",
+           output->last_frame_time / 1000, time);
+#endif
+}
+
 static Bool
 x_sync_is_frame_drawn_event (Display *dpy, XEvent *event,
                              XPointer user_data)
@@ -6689,7 +6738,12 @@ x_sync_wait_for_frame_drawn_event (struct frame *f)
       fprintf (stderr, "Warning: compositing manager spent more than 1 second "
                "drawing a frame.  Frame synchronization has been disabled\n");
       FRAME_X_OUTPUT (f)->use_vsync_p = false;
+
+      /* Also change the frame parameter to reflect the new state.  */
+      store_frame_param (f, Quse_frame_synchronization, Qnil);
     }
+  else
+    x_sync_note_frame_times (FRAME_DISPLAY_INFO (f), f, &event);
 
   FRAME_X_WAITING_FOR_DRAW (f) = false;
 }
@@ -6735,6 +6789,10 @@ x_sync_update_begin (struct frame *f)
   /* Wait for the last frame to be drawn before drawing this one.  */
   x_sync_wait_for_frame_drawn_event (f);
 
+  /* Make a note of the time at which we started to draw this
+     frame.  */
+  FRAME_X_OUTPUT (f)->temp_frame_time = x_sync_current_monotonic_time ();
+
   /* Since Emacs needs a non-urgent redraw, ensure that value % 4 ==
      1.  Later, add 3 to create the even counter value.  */
   if (XSyncValueLow32 (value) % 4 == 2)
@@ -6755,6 +6813,85 @@ x_sync_update_begin (struct frame *f)
                    FRAME_X_COUNTER_VALUE (f));
 }
 
+#ifdef HAVE_XSYNCTRIGGERFENCE
+
+/* Trigger the sync fence for counter VALUE immediately before a frame
+   finishes.  */
+
+static void
+x_sync_trigger_fence (struct frame *f, XSyncValue value)
+{
+  uint64_t n, low, high, idx;
+
+  /* Sync fences aren't supported by the X server.  */
+  if (FRAME_DISPLAY_INFO (f)->xsync_major < 3
+      || (FRAME_DISPLAY_INFO (f)->xsync_major == 3
+          && FRAME_DISPLAY_INFO (f)->xsync_minor < 1))
+    return;
+
+  low = XSyncValueLow32 (value);
+  high = XSyncValueHigh32 (value);
+
+  n = low | (high << 32);
+  idx = (n / 4) % 2;
+
+#ifdef FRAME_DEBUG
+  fprintf (stderr, "Triggering synchronization fence: %lu\n", idx);
+#endif
+
+  XSyncTriggerFence (FRAME_X_DISPLAY (f),
+                     FRAME_X_OUTPUT (f)->sync_fences[idx]);
+}
+
+/* Initialize the sync fences on F.  */
+
+void
+x_sync_init_fences (struct frame *f)
+{
+  struct x_output *output;
+  struct x_display_info *dpyinfo;
+
+  output = FRAME_X_OUTPUT (f);
+  dpyinfo = FRAME_DISPLAY_INFO (f);
+
+  /* Sync fences aren't supported by the X server.  */
+  if (dpyinfo->xsync_major < 3
+      || (dpyinfo->xsync_major == 3
+          && dpyinfo->xsync_minor < 1))
+    return;
+
+  output->sync_fences[0]
+    = XSyncCreateFence (FRAME_X_DISPLAY (f),
+                        /* The drawable given below is only used to
+                           determine the screen on which the fence is
+                           created.  */
+                        FRAME_X_WINDOW (f),
+                        False);
+  output->sync_fences[1]
+    = XSyncCreateFence (FRAME_X_DISPLAY (f),
+                        FRAME_X_WINDOW (f),
+                        False);
+
+  XChangeProperty (FRAME_X_DISPLAY (f), FRAME_OUTER_WINDOW (f),
+                   dpyinfo->Xatom_net_wm_sync_fences, XA_CARDINAL,
+                   32, PropModeReplace,
+                   (unsigned char *) &output->sync_fences, 2);
+}
+
+static void
+x_sync_free_fences (struct frame *f)
+{
+  if (FRAME_X_OUTPUT (f)->sync_fences[0] != None)
+    XSyncDestroyFence (FRAME_X_DISPLAY (f),
+                       FRAME_X_OUTPUT (f)->sync_fences[0]);
+
+  if (FRAME_X_OUTPUT (f)->sync_fences[1] != None)
+    XSyncDestroyFence (FRAME_X_DISPLAY (f),
+                       FRAME_X_OUTPUT (f)->sync_fences[1]);
+}
+
+#endif
+
 /* Tell the compositing manager that FRAME has been drawn and can be
    updated.  */
 
@@ -6787,12 +6924,15 @@ x_sync_update_finish (struct frame *f)
   if (overflow)
     XSyncIntToValue (&FRAME_X_COUNTER_VALUE (f), 0);
 
+  /* Trigger any sync fences if necessary.  */
+#ifdef HAVE_XSYNCTRIGGERFENCE
+  x_sync_trigger_fence (f, FRAME_X_COUNTER_VALUE (f));
+#endif
+
   XSyncSetCounter (FRAME_X_DISPLAY (f),
                    FRAME_X_EXTENDED_COUNTER (f),
                    FRAME_X_COUNTER_VALUE (f));
 
-  /* FIXME: this leads to freezes if the compositing manager crashes
-     in the meantime.  */
   if (FRAME_OUTPUT_DATA (f)->use_vsync_p)
     FRAME_X_WAITING_FOR_DRAW (f) = true;
 }
@@ -6805,6 +6945,8 @@ x_sync_handle_frame_drawn (struct x_display_info *dpyinfo,
 {
   if (FRAME_OUTER_WINDOW (f) == message->xclient.window)
     FRAME_X_WAITING_FOR_DRAW (f) = false;
+
+  x_sync_note_frame_times (dpyinfo, f, message);
 }
 #endif
 
@@ -7388,6 +7530,9 @@ x_display_set_last_user_time (struct x_display_info *dpyinfo, Time time,
 #ifndef USE_GTK
   struct frame *focus_frame;
   Time old_time;
+#if defined HAVE_XSYNC
+  uint64_t monotonic_time;
+#endif
 
   focus_frame = dpyinfo->x_focus_frame;
   old_time = dpyinfo->last_user_time;
@@ -7400,6 +7545,28 @@ x_display_set_last_user_time (struct x_display_info *dpyinfo, Time time,
   if (!send_event || time > dpyinfo->last_user_time)
     dpyinfo->last_user_time = time;
 
+#if defined HAVE_XSYNC && !defined USE_GTK
+  if (!send_event)
+    {
+      /* See if the current CLOCK_MONOTONIC time is reasonably close
+         to the X server time.  */
+      monotonic_time = x_sync_current_monotonic_time ();
+
+      if (time * 1000 > monotonic_time - 500 * 1000
+          && time * 1000 < monotonic_time + 500 * 1000)
+        dpyinfo->server_time_monotonic_p = true;
+      else
+        {
+          /* Compute an offset that can be subtracted from the server
+             time to estimate the monotonic time on the X server.  */
+
+          dpyinfo->server_time_monotonic_p = false;
+          dpyinfo->server_time_offset
+            = ((int64_t) time * 1000) - monotonic_time;
+        }
+    }
+#endif
+
 #ifndef USE_GTK
   /* Don't waste bandwidth if the time hasn't actually changed.  */
   if (focus_frame && old_time != dpyinfo->last_user_time)
@@ -7419,6 +7586,26 @@ x_display_set_last_user_time (struct x_display_info *dpyinfo, Time time,
 #endif
 }
 
+#ifdef USE_GTK
+
+static void
+x_set_gtk_user_time (struct frame *f, Time time)
+{
+  GtkWidget *widget;
+  GdkWindow *window;
+
+  widget = FRAME_GTK_OUTER_WIDGET (f);
+  window = gtk_widget_get_window (widget);
+
+  /* This widget isn't realized yet.  */
+  if (!window)
+    return;
+
+  gdk_x11_window_set_user_time (window, time);
+}
+
+#endif
+
 /* Not needed on GTK because GTK handles reporting the user time
    itself.  */
 
@@ -9308,9 +9495,7 @@ x_composite_image (struct glyph_string *s, Pixmap dest,
     {
       Picture destination;
       XRenderPictFormat *default_format;
-      XRenderPictureAttributes attr;
-      /* Pacify GCC.  */
-      memset (&attr, 0, sizeof attr);
+      XRenderPictureAttributes attr UNINIT;
 
       default_format = FRAME_X_PICTURE_FORMAT (s->f);
       destination = XRenderCreatePicture (display, dest,
@@ -10466,16 +10651,12 @@ x_clear_frame (struct frame *f)
   mark_window_cursors_off (XWINDOW (FRAME_ROOT_WINDOW (f)));
 
   block_input ();
-
   font_drop_xrender_surfaces (f);
   x_clear_window (f);
 
   /* We have to clear the scroll bars.  If we have changed colors or
      something like that, then they should be notified.  */
   x_scroll_bar_clear (f);
-
-  XFlush (FRAME_X_DISPLAY (f));
-
   unblock_input ();
 }
 
@@ -10853,7 +11034,6 @@ x_scroll_run (struct window *w, struct run *run)
                                                    view->clip_bottom - view->clip_top);
                     }
                   xwidget_expose (view);
-                  XFlush (dpy);
                 }
             }
         }
@@ -12286,6 +12466,459 @@ x_dnd_begin_drag_and_drop (struct frame *f, Time time, Atom xaction,
   return unbind_to (base, Qnil);
 }
 
+#ifdef HAVE_XINPUT2
+
+/* Since the input extension assigns a keyboard focus to each master
+   device, there is no longer a 1:1 correspondence between the
+   selected frame and the focus frame immediately after the keyboard
+   focus is switched to a given frame.  This situation is handled by
+   keeping track of each master device's focus frame, the time of the
+   last interaction with that frame, and always keeping the focus on
+   the most recently selected frame.  We also use the pointer of the
+   device that is keeping the current frame focused in functions like
+   `mouse-position'.  */
+
+static void
+xi_handle_focus_change (struct x_display_info *dpyinfo)
+{
+  struct input_event ie;
+  struct frame *focus, *new;
+  struct xi_device_t *device, *source = NULL;
+  ptrdiff_t i;
+  Time time;
+#ifdef USE_GTK
+  struct x_output *output;
+  GtkWidget *widget;
+#endif
+
+  focus = dpyinfo->x_focus_frame;
+  new = NULL;
+  time = 0;
+
+  dpyinfo->client_pointer_device = -1;
+
+  for (i = 0; i < dpyinfo->num_devices; ++i)
+    {
+      device = &dpyinfo->devices[i];
+
+      if (device->focus_frame
+          && device->focus_frame_time > time)
+        {
+          new = device->focus_frame;
+          time = device->focus_frame_time;
+          source = device;
+
+          /* Use this device for future calls to `mouse-position' etc.
+             If it is a keyboard, use its attached pointer.  */
+
+          if (device->use == XIMasterKeyboard)
+            dpyinfo->client_pointer_device = device->attachment;
+          else
+            dpyinfo->client_pointer_device = device->device_id;
+        }
+
+      if (device->focus_implicit_frame
+          && device->focus_implicit_time > time)
+        {
+          new = device->focus_implicit_frame;
+          time = device->focus_implicit_time;
+          source = device;
+
+          /* Use this device for future calls to `mouse-position' etc.
+             If it is a keyboard, use its attached pointer.  */
+
+          if (device->use == XIMasterKeyboard)
+            dpyinfo->client_pointer_device = device->attachment;
+          else
+            dpyinfo->client_pointer_device = device->device_id;
+        }
+    }
+
+  if (new != focus && focus)
+    {
+#ifdef HAVE_X_I18N
+      if (FRAME_XIC (focus))
+        XUnsetICFocus (FRAME_XIC (focus));
+#endif
+
+#ifdef USE_GTK
+      output = FRAME_X_OUTPUT (focus);
+
+      if (x_gtk_use_native_input)
+        {
+          gtk_im_context_focus_out (output->im_context);
+          gtk_im_context_set_client_window (output->im_context,
+                                            NULL);
+        }
+#endif
+
+      EVENT_INIT (ie);
+      ie.kind = FOCUS_OUT_EVENT;
+      XSETFRAME (ie.frame_or_window, focus);
+
+      kbd_buffer_store_event (&ie);
+    }
+
+  if (new != focus && new)
+    {
+#ifdef HAVE_X_I18N
+      if (FRAME_XIC (new))
+        XSetICFocus (FRAME_XIC (new));
+#endif
+
+#ifdef USE_GTK
+      output = FRAME_X_OUTPUT (new);
+
+      if (x_gtk_use_native_input)
+        {
+          widget = FRAME_GTK_OUTER_WIDGET (new);
+
+          gtk_im_context_focus_in (output->im_context);
+          gtk_im_context_set_client_window (output->im_context,
+                                            gtk_widget_get_window (widget));
+        }
+#endif
+
+      EVENT_INIT (ie);
+      ie.kind = FOCUS_IN_EVENT;
+      ie.device = source->name;
+      XSETFRAME (ie.frame_or_window, new);
+
+      kbd_buffer_store_event (&ie);
+    }
+
+  x_new_focus_frame (dpyinfo, new);
+}
+
+static void
+xi_focus_handle_for_device (struct x_display_info *dpyinfo,
+                            struct frame *mentioned_frame,
+                            XIEvent *base_event)
+{
+  struct xi_device_t *device;
+  XIEnterEvent *event;
+
+  /* XILeaveEvent, XIFocusInEvent, etc are just synonyms for
+     XIEnterEvent.  */
+  event = (XIEnterEvent *) base_event;
+  device = xi_device_from_id (dpyinfo, event->deviceid);
+
+  if (!device)
+    return;
+
+  switch (event->evtype)
+    {
+    case XI_FocusIn:
+      device->focus_frame = mentioned_frame;
+      device->focus_frame_time = event->time;
+      break;
+
+    case XI_FocusOut:
+      device->focus_frame = NULL;
+      break;
+
+    case XI_Enter:
+      if (!event->focus)
+        break;
+
+      if (device->use == XIMasterPointer)
+        device = xi_device_from_id (dpyinfo, device->attachment);
+
+      if (!device)
+        break;
+
+      device->focus_implicit_frame = mentioned_frame;
+      device->focus_implicit_time = event->time;
+      break;
+
+    case XI_Leave:
+      if (!event->focus)
+        break;
+
+      if (device->use == XIMasterPointer)
+        device = xi_device_from_id (dpyinfo, device->attachment);
+
+      if (!device)
+        break;
+
+      device->focus_implicit_frame = NULL;
+      break;
+    }
+
+  xi_handle_focus_change (dpyinfo);
+}
+
+static void
+xi_handle_delete_frame (struct x_display_info *dpyinfo,
+                        struct frame *f)
+{
+  struct xi_device_t *device;
+  ptrdiff_t i;
+
+  for (i = 0; i < dpyinfo->num_devices; ++i)
+    {
+      device = &dpyinfo->devices[i];
+
+      if (device->focus_frame == f)
+        device->focus_frame = NULL;
+
+      if (device->focus_implicit_frame == f)
+        device->focus_implicit_frame = NULL;
+    }
+}
+
+/* Handle an interaction by DEVICE on frame F.  TIME is the time of
+   the interaction; if F isn't currently the global focus frame, but
+   is the focus of DEVICE, make it the focus frame.  */
+
+static void
+xi_handle_interaction (struct x_display_info *dpyinfo,
+                       struct frame *f, struct xi_device_t *device,
+                       Time time)
+{
+  bool change;
+
+  /* If DEVICE is a pointer, use its attached keyboard device.  */
+  if (device->use == XIMasterPointer)
+    device = xi_device_from_id (dpyinfo, device->attachment);
+
+  if (!device)
+    return;
+
+  change = false;
+
+  if (device->focus_frame == f)
+    {
+      device->focus_frame_time = time;
+      change = true;
+    }
+
+  if (device->focus_implicit_frame == f)
+    {
+      device->focus_implicit_time = time;
+      change = true;
+    }
+
+  /* If F isn't currently focused, update the focus state.  */
+  if (change && f != dpyinfo->x_focus_frame)
+    xi_handle_focus_change (dpyinfo);
+}
+
+#ifdef HAVE_XINPUT2_1
+
+/* Look up a scroll valuator in DEVICE by NUMBER.  */
+
+static struct xi_scroll_valuator_t *
+xi_get_scroll_valuator (struct xi_device_t *device, int number)
+{
+  int i;
+
+  for (i = 0; i < device->scroll_valuator_count; ++i)
+    {
+      if (device->valuators[i].number == number)
+        return &device->valuators[i];
+    }
+
+  return NULL;
+}
+
+#endif
+
+/* Handle EVENT, a DeviceChanged event.  Look up the device that
+   changed, and update its information with the data in EVENT.  */
+
+static void
+xi_handle_device_changed (struct x_display_info *dpyinfo,
+                          struct xi_device_t *device,
+                          XIDeviceChangedEvent *event)
+{
+#ifdef HAVE_XINPUT2_1
+  XIDeviceInfo *info;
+  XIScrollClassInfo *scroll;
+  int i, ndevices;
+  struct xi_scroll_valuator_t *valuator;
+  XIValuatorClassInfo *valuator_info;
+#endif
+#ifdef HAVE_XINPUT2_2
+  struct xi_touch_point_t *tem, *last;
+  XITouchClassInfo *touch;
+#endif
+
+#ifdef HAVE_XINPUT2_1
+  /* When a DeviceChange event is received for a master device, we
+     don't get any scroll valuators along with it.  This is possibly
+     an X server bug but I really don't want to dig any further, so
+     fetch the scroll valuators manually.  (bug#57020) */
+
+  x_catch_errors (dpyinfo->display);
+  info = XIQueryDevice (dpyinfo->display, event->deviceid,
+                        /* ndevices is always 1 if a deviceid is
+                           specified.  If the request fails, NULL will
+                           be returned.  */
+                        &ndevices);
+  x_uncatch_errors ();
+
+  if (info)
+    {
+      device->valuators = xrealloc (device->valuators,
+                                    (info->num_classes
+                                     * sizeof *device->valuators));
+      device->scroll_valuator_count = 0;
+#ifdef HAVE_XINPUT2_2
+      device->direct_p = false;
+#endif
+
+      for (i = 0; i < info->num_classes; ++i)
+        {
+          switch (info->classes[i]->type)
+            {
+            case XIScrollClass:
+              scroll = (XIScrollClassInfo *) info->classes[i];
+
+              valuator = &device->valuators[device->scroll_valuator_count++];
+              valuator->horizontal = (scroll->scroll_type
+                                      == XIScrollTypeHorizontal);
+              valuator->invalid_p = true;
+              valuator->emacs_value = DBL_MIN;
+              valuator->increment = scroll->increment;
+              valuator->number = scroll->number;
+              break;
+
+#ifdef HAVE_XINPUT2_2
+            case XITouchClass:
+              touch = (XITouchClassInfo *) info->classes[i];
+
+              if (touch->mode == XIDirectTouch)
+                device->direct_p = true;
+              break;
+#endif
+            }
+        }
+
+      /* Restore the values of any scroll valuators that we already
+         know about.  */
+
+      for (i = 0; i < info->num_classes; ++i)
+        {
+          switch (info->classes[i]->type)
+            {
+            case XIValuatorClass:
+              valuator_info = (XIValuatorClassInfo *) info->classes[i];
+
+              valuator = xi_get_scroll_valuator (device,
+                                                 valuator_info->number);
+              if (valuator)
+                {
+                  valuator->invalid_p = false;
+                  valuator->current_value = valuator_info->value;
+
+                  /* Make sure that this is reset if the pointer moves
+                     into a window of ours.
+
+                     Otherwise the valuator state could be left
+                     invalid if the DeviceChange event happened with
+                     the pointer outside any Emacs frame. */
+                  valuator->pending_enter_reset = true;
+                }
+
+              break;
+            }
+        }
+
+#ifdef HAVE_XINPUT2_2
+      /* The device is no longer a DirectTouch device, so
+         remove any touchpoints that we might have
+         recorded.  */
+      if (!device->direct_p)
+        {
+          tem = device->touchpoints;
+
+          while (tem)
+            {
+              last = tem;
+              tem = tem->next;
+              xfree (last);
+            }
+
+          device->touchpoints = NULL;
+        }
+#endif
+
+      XIFreeDeviceInfo (info);
+    }
+#endif
+}
+
+/* Remove the client-side record of every device in TO_DISABLE.
+   Called while processing XI_HierarchyChanged events.  We batch up
+   multiple disabled devices because it is more efficient to disable
+   them at once.  */
+
+static void
+xi_disable_devices (struct x_display_info *dpyinfo,
+                    int *to_disable, int n_disabled)
+{
+  struct xi_device_t *devices;
+  int ndevices, i, j;
+#ifdef HAVE_XINPUT2_2
+  struct xi_touch_point_t *tem, *last;
+#endif
+
+  /* Don't pointlessly copy dpyinfo->devices if there are no devices
+     to disable.  */
+  if (!n_disabled)
+    return;
+
+  ndevices = 0;
+  devices = xzalloc (sizeof *devices * dpyinfo->num_devices);
+
+  /* Loop through every device currently in DPYINFO, and copy it to
+     DEVICES if it is not in TO_DISABLE.  Note that this function
+     should be called with input blocked, since xfree can otherwise
+     call GC, which will call mark_xterm with invalid state.  */
+  for (i = 0; i < dpyinfo->num_devices; ++i)
+    {
+      for (j = 0; j < n_disabled; ++j)
+        {
+          if (to_disable[j] == dpyinfo->devices[i].device_id)
+            {
+              /* Free any scroll valuators that might be on this
+                 device.  */
+#ifdef HAVE_XINPUT2_1
+              xfree (dpyinfo->devices[i].valuators);
+#endif
+
+              /* Free any currently active touch points on this
+                 device.  */
+#ifdef HAVE_XINPUT2_2
+              tem = dpyinfo->devices[i].touchpoints;
+              while (tem)
+                {
+                  last = tem;
+                  tem = tem->next;
+                  xfree (last);
+                }
+#endif
+
+              goto out;
+            }
+
+          devices[ndevices++] = dpyinfo->devices[i];
+
+        out:
+          continue;
+        }
+    }
+
+  /* Free the old devices array and replace it with ndevices.  */
+  xfree (dpyinfo->devices);
+
+  dpyinfo->devices = devices;
+  dpyinfo->num_devices = ndevices;
+}
+
+#endif
+
 /* The focus may have changed.  Figure out if it is a real focus change,
    by checking both FocusIn/Out and Enter/LeaveNotify events.
 
@@ -12316,37 +12949,6 @@ x_detect_focus_change (struct x_display_info *dpyinfo, struct frame *frame,
       }
       break;
 
-#ifdef HAVE_XINPUT2
-    case GenericEvent:
-      {
-        XIEvent *xi_event = event->xcookie.data;
-        XIEnterEvent *enter_or_focus = event->xcookie.data;
-
-        struct frame *focus_frame = dpyinfo->x_focus_event_frame;
-        int focus_state
-          = focus_frame ? focus_frame->output_data.x->focus_state : 0;
-
-        if (xi_event->evtype == XI_FocusIn
-            || xi_event->evtype == XI_FocusOut)
-          x_focus_changed ((xi_event->evtype == XI_FocusIn
-                            ? FocusIn : FocusOut),
-                           ((enter_or_focus->detail
-                             == XINotifyPointer)
-                            ? FOCUS_IMPLICIT : FOCUS_EXPLICIT),
-                             dpyinfo, frame, bufp);
-        else if ((xi_event->evtype == XI_Enter
-                  || xi_event->evtype == XI_Leave)
-                 && (enter_or_focus->detail != XINotifyInferior)
-                 && enter_or_focus->focus
-                 && !(focus_state & FOCUS_EXPLICIT))
-          x_focus_changed ((xi_event->evtype == XI_Enter
-                            ? FocusIn : FocusOut),
-                           FOCUS_IMPLICIT,
-                           dpyinfo, frame, bufp);
-        break;
-      }
-#endif
-
     case FocusIn:
     case FocusOut:
       /* Ignore transient focus events from hotkeys, window manager
@@ -12692,6 +13294,68 @@ get_keysym_name (int keysym)
   return value;
 }
 
+/* Like XQueryPointer, but always use the right client pointer
+   device.  */
+
+Bool
+x_query_pointer (Display *dpy, Window w, Window *root_return,
+                 Window *child_return, int *root_x_return,
+                 int *root_y_return, int *win_x_return,
+                 int *win_y_return, unsigned int *mask_return)
+{
+  Bool rc;
+#ifdef HAVE_XINPUT2
+  struct x_display_info *dpyinfo;
+  bool had_errors;
+  XIModifierState modifiers;
+  XIButtonState buttons;
+  XIGroupState group; /* Unused.  */
+  double root_x, root_y, win_x, win_y;
+  unsigned int state;
+#endif
+
+#ifdef HAVE_XINPUT2
+  dpyinfo = x_display_info_for_display (dpy);
+  if (dpyinfo && dpyinfo->client_pointer_device != -1)
+    {
+      /* Catch errors caused by the device going away.  This is not
+         very expensive, since XIQueryPointer will sync anyway.  */
+      x_catch_errors (dpy);
+      rc = XIQueryPointer (dpyinfo->display,
+                           dpyinfo->client_pointer_device,
+                           w, root_return, child_return,
+                           &root_x, &root_y, &win_x, &win_y,
+                           &buttons, &modifiers, &group);
+      had_errors = x_had_errors_p (dpy);
+      x_uncatch_errors_after_check ();
+
+      if (had_errors)
+        rc = XQueryPointer (dpyinfo->display, w, root_return,
+                            child_return, root_x_return,
+                            root_y_return, win_x_return,
+                            win_y_return, mask_return);
+      else
+        {
+          state = 0;
+
+          xi_convert_button_state (&buttons, &state);
+          *mask_return = state | modifiers.effective;
+
+          *root_x_return = lrint (root_x);
+          *root_y_return = lrint (root_y);
+          *win_x_return = lrint (win_x);
+          *win_y_return = lrint (win_y);
+        }
+    }
+  else
+#endif
+    rc = XQueryPointer (dpy, w, root_return, child_return,
+                        root_x_return, root_y_return, win_x_return,
+                        win_y_return, mask_return);
+
+  return rc;
+}
+
 /* Mouse clicks and mouse movement.  Rah.
 
    Formerly, we used PointerMotionHintMask (in standard_event_mask)
@@ -12958,20 +13622,20 @@ XTmouse_position (struct frame **fp, int insist, Lisp_Object *bar_window,
       dpyinfo->last_mouse_scroll_bar = NULL;
 
       /* Figure out which root window we're on.  */
-      XQueryPointer (FRAME_X_DISPLAY (*fp),
-                     DefaultRootWindow (FRAME_X_DISPLAY (*fp)),
-                     /* The root window which contains the pointer.  */
-                     &root,
-                     /* Trash which we can't trust if the pointer is on
-                        a different screen.  */
-                     &dummy_window,
-                     /* The position on that root window.  */
-                     &root_x, &root_y,
-                     /* More trash we can't trust.  */
-                     &dummy, &dummy,
-                     /* Modifier keys and pointer buttons, about which
-                        we don't care.  */
-                     (unsigned int *) &dummy);
+      x_query_pointer (FRAME_X_DISPLAY (*fp),
+                       DefaultRootWindow (FRAME_X_DISPLAY (*fp)),
+                       /* The root window which contains the pointer.  */
+                       &root,
+                       /* Trash which we can't trust if the pointer is on
+                          a different screen.  */
+                       &dummy_window,
+                       /* The position on that root window.  */
+                       &root_x, &root_y,
+                       /* More trash we can't trust.  */
+                       &dummy, &dummy,
+                       /* Modifier keys and pointer buttons, about which
+                          we don't care.  */
+                       (unsigned int *) &dummy);
 
       /* Now we have a position on the root; find the innermost window
          containing the pointer.  */
@@ -13206,6 +13870,37 @@ XTmouse_position (struct frame **fp, int insist, Lisp_Object *bar_window,
 
 /* Scroll bar support.  */
 
+#if defined HAVE_XINPUT2
+
+/* Select for input extension events used by scroll bars.  This will
+   result in the corresponding core events not being generated for
+   SCROLL_BAR.  */
+
+MAYBE_UNUSED static void
+xi_select_scroll_bar_events (struct x_display_info *dpyinfo,
+                             Window scroll_bar)
+{
+  XIEventMask mask;
+  unsigned char *m;
+  ptrdiff_t length;
+
+  length = XIMaskLen (XI_LASTEVENT);
+  mask.mask = m = alloca (length);
+  memset (m, 0, length);
+  mask.mask_len = length;
+
+  mask.deviceid = XIAllMasterDevices;
+  XISetMask (m, XI_ButtonPress);
+  XISetMask (m, XI_ButtonRelease);
+  XISetMask (m, XI_Motion);
+  XISetMask (m, XI_Enter);
+  XISetMask (m, XI_Leave);
+
+  XISelectEvents (dpyinfo->display, scroll_bar, &mask, 1);
+}
+
+#endif
+
 /* Given an X window ID and a DISPLAY, find the struct scroll_bar which
    manages it.
    This can be called in GC, so we have to make sure to strip off mark
@@ -13996,25 +14691,8 @@ x_create_toolkit_scroll_bar (struct frame *f, struct scroll_bar *bar)
   /* Ask for input extension button and motion events.  This lets us
      send the proper `wheel-up' or `wheel-down' events to Emacs.  */
   if (FRAME_DISPLAY_INFO (f)->supports_xi2)
-    {
-      XIEventMask mask;
-      ptrdiff_t l = XIMaskLen (XI_LASTEVENT);
-      unsigned char *m;
-
-      mask.mask = m = alloca (l);
-      memset (m, 0, l);
-      mask.mask_len = l;
-
-      mask.deviceid = XIAllMasterDevices;
-      XISetMask (m, XI_ButtonPress);
-      XISetMask (m, XI_ButtonRelease);
-      XISetMask (m, XI_Motion);
-      XISetMask (m, XI_Enter);
-      XISetMask (m, XI_Leave);
-
-      XISelectEvents (XtDisplay (widget), XtWindow (widget),
-                      &mask, 1);
-    }
+    xi_select_scroll_bar_events (FRAME_DISPLAY_INFO (f),
+                                 XtWindow (widget));
 #endif
 #else /* !USE_MOTIF i.e. use Xaw */
 
@@ -14221,25 +14899,8 @@ x_create_horizontal_toolkit_scroll_bar (struct frame *f, struct scroll_bar *bar)
   /* Ask for input extension button and motion events.  This lets us
      send the proper `wheel-up' or `wheel-down' events to Emacs.  */
   if (FRAME_DISPLAY_INFO (f)->supports_xi2)
-    {
-      XIEventMask mask;
-      ptrdiff_t l = XIMaskLen (XI_LASTEVENT);
-      unsigned char *m;
-
-      mask.mask = m = alloca (l);
-      memset (m, 0, l);
-      mask.mask_len = l;
-
-      mask.deviceid = XIAllMasterDevices;
-      XISetMask (m, XI_ButtonPress);
-      XISetMask (m, XI_ButtonRelease);
-      XISetMask (m, XI_Motion);
-      XISetMask (m, XI_Enter);
-      XISetMask (m, XI_Leave);
-
-      XISelectEvents (XtDisplay (widget), XtWindow (widget),
-                      &mask, 1);
-    }
+    xi_select_scroll_bar_events (FRAME_DISPLAY_INFO (f),
+                                 XtWindow (widget));
 #endif
 #else /* !USE_MOTIF i.e. use Xaw */
 
@@ -14661,24 +15322,8 @@ x_scroll_bar_create (struct window *w, int top, int left,
   /* Ask for input extension button and motion events.  This lets us
      send the proper `wheel-up' or `wheel-down' events to Emacs.  */
   if (FRAME_DISPLAY_INFO (f)->supports_xi2)
-    {
-      XIEventMask mask;
-      ptrdiff_t l = XIMaskLen (XI_LASTEVENT);
-      unsigned char *m;
-
-      mask.mask = m = alloca (l);
-      memset (m, 0, l);
-      mask.mask_len = l;
-
-      mask.deviceid = XIAllMasterDevices;
-      XISetMask (m, XI_ButtonPress);
-      XISetMask (m, XI_ButtonRelease);
-      XISetMask (m, XI_Motion);
-      XISetMask (m, XI_Enter);
-      XISetMask (m, XI_Leave);
-
-      XISelectEvents (FRAME_X_DISPLAY (f), window, &mask, 1);
-    }
+    xi_select_scroll_bar_events (FRAME_DISPLAY_INFO (f),
+                                 window);
 #endif
 
     bar->x_window = window;
@@ -15563,17 +16208,17 @@ x_scroll_bar_report_motion (struct frame **fp, Lisp_Object *bar_window,
 
   /* Get the mouse's position relative to the scroll bar window, and
      report that.  */
-  if (XQueryPointer (FRAME_X_DISPLAY (f), w,
+  if (x_query_pointer (FRAME_X_DISPLAY (f), w,
 
-                     /* Root, child, root x and root y.  */
-                     &dummy_window, &dummy_window,
-                     &dummy_coord, &dummy_coord,
+                       /* Root, child, root x and root y.  */
+                       &dummy_window, &dummy_window,
+                       &dummy_coord, &dummy_coord,
 
-                     /* Position relative to scroll bar.  */
-                     &win_x, &win_y,
+                       /* Position relative to scroll bar.  */
+                       &win_x, &win_y,
 
-                     /* Mouse buttons and modifier keys.  */
-                     &dummy_mask))
+                       /* Mouse buttons and modifier keys.  */
+                       &dummy_mask))
     {
       int top_range = VERTICAL_SCROLL_BAR_TOP_RANGE (f, bar->height);
 
@@ -15632,17 +16277,17 @@ x_horizontal_scroll_bar_report_motion (struct frame **fp, Lisp_Object *bar_windo
 
   /* Get the mouse's position relative to the scroll bar window, and
      report that.  */
-  if (XQueryPointer (FRAME_X_DISPLAY (f), w,
+  if (x_query_pointer (FRAME_X_DISPLAY (f), w,
 
-                     /* Root, child, root x and root y.  */
-                     &dummy_window, &dummy_window,
-                     &dummy_coord, &dummy_coord,
+                       /* Root, child, root x and root y.  */
+                       &dummy_window, &dummy_window,
+                       &dummy_coord, &dummy_coord,
 
-                     /* Position relative to scroll bar.  */
-                     &win_x, &win_y,
+                       /* Position relative to scroll bar.  */
+                       &win_x, &win_y,
 
-                     /* Mouse buttons and modifier keys.  */
-                     &dummy_mask))
+                       /* Mouse buttons and modifier keys.  */
+                       &dummy_mask))
     {
       int left_range = HORIZONTAL_SCROLL_BAR_LEFT_RANGE (f, bar->width);
 
@@ -16501,6 +17146,29 @@ x_wait_for_cell_change (Lisp_Object cell, struct timespec timeout)
     }
 }
 
+/* Find whether or not an undelivered MONITORS_CHANGED_EVENT is
+   already on the event queue.  DPYINFO is the display any such event
+   must apply to.  */
+
+static bool
+x_find_monitors_changed_event (struct x_display_info *dpyinfo)
+{
+  union buffered_input_event *event;
+
+  event = kbd_fetch_ptr;
+
+  while (event != kbd_store_ptr)
+    {
+      if (event->ie.kind == MONITORS_CHANGED_EVENT
+          && XTERMINAL (event->ie.arg) == dpyinfo->terminal)
+        return true;
+
+      event = X_NEXT_KBD_EVENT (event);
+    }
+
+  return false;
+}
+
 #ifdef USE_GTK
 static void
 x_monitors_changed_cb (GdkScreen *gscr, gpointer user_data)
@@ -16518,6 +17186,9 @@ x_monitors_changed_cb (GdkScreen *gscr, gpointer user_data)
   if (!dpyinfo)
     return;
 
+  if (x_find_monitors_changed_event (dpyinfo))
+    return;
+
   XSETTERMINAL (terminal, dpyinfo->terminal);
 
   current_monitors
@@ -16645,6 +17316,10 @@ handle_one_xevent (struct x_display_info *dpyinfo,
   union buffered_input_event inev;
   int count = 0;
   int do_help = 0;
+#ifdef HAVE_XINPUT2
+  struct xi_device_t *gen_help_device;
+  Time gen_help_time;
+#endif
   ptrdiff_t nbytes = 0;
   struct frame *any, *f = NULL;
   Mouse_HLInfo *hlinfo = &dpyinfo->mouse_highlight;
@@ -16674,6 +17349,9 @@ handle_one_xevent (struct x_display_info *dpyinfo,
   EVENT_INIT (inev.ie);
   inev.ie.kind = NO_EVENT;
   inev.ie.arg = Qnil;
+#ifdef HAVE_XINPUT2
+  gen_help_device = NULL;
+#endif
 
   /* Ignore events coming from various extensions, such as XFIXES and
      XKB.  */
@@ -17172,7 +17850,8 @@ handle_one_xevent (struct x_display_info *dpyinfo,
           goto done;
 #endif
 
-        xft_settings_event (dpyinfo, event);
+        if (xft_settings_event (dpyinfo, event))
+          goto done;
 
         f = any;
         /* We don't want to ever leak tooltip frames to Lisp code.  */
@@ -17198,6 +17877,12 @@ handle_one_xevent (struct x_display_info *dpyinfo,
       if (!x_window_to_frame (dpyinfo, event->xselection.requestor))
         goto OTHER;
 #endif /* not USE_X_TOOLKIT and not USE_GTK */
+#ifdef HAVE_GTK3
+      /* GTK 3 apparently chokes on these events since they have no
+         associated device.  (bug#56869, another bug as well that I
+         can't find) */
+      *finish = X_EVENT_DROP;
+#endif
       x_handle_selection_notify (&event->xselection);
       break;
 
@@ -17206,6 +17891,9 @@ handle_one_xevent (struct x_display_info *dpyinfo,
       if (!x_window_to_frame (dpyinfo, event->xselectionclear.window))
         goto OTHER;
 #endif /* not USE_X_TOOLKIT and not USE_GTK */
+#ifdef HAVE_GTK3
+      *finish = X_EVENT_DROP;
+#endif
       {
         const XSelectionClearEvent *eventp = &event->xselectionclear;
 
@@ -17232,6 +17920,9 @@ handle_one_xevent (struct x_display_info *dpyinfo,
       if (!x_window_to_frame (dpyinfo, event->xselectionrequest.owner))
         goto OTHER;
 #endif /* USE_X_TOOLKIT */
+#ifdef HAVE_GTK3
+      *finish = X_EVENT_DROP;
+#endif
       {
         const XSelectionRequestEvent *eventp = &event->xselectionrequest;
 
@@ -17873,6 +18564,7 @@ handle_one_xevent (struct x_display_info *dpyinfo,
       x_display_set_last_user_time (dpyinfo, event->xkey.time,
                                     event->xkey.send_event);
       ignore_next_mouse_click_timeout = 0;
+
       coding = Qlatin_1;
 
 #if defined (USE_X_TOOLKIT) || defined (USE_GTK)
@@ -17883,6 +18575,11 @@ handle_one_xevent (struct x_display_info *dpyinfo,
 
       f = any;
 
+#ifdef USE_GTK
+      if (f)
+        x_set_gtk_user_time (f, event->xkey.time);
+#endif
+
       /* If mouse-highlight is an integer, input clears out
          mouse highlighting.  */
       if (!hlinfo->mouse_face_hidden && FIXNUMP (Vmouse_highlight)
@@ -18462,7 +19159,7 @@ handle_one_xevent (struct x_display_info *dpyinfo,
         {
           /* Now clear dpyinfo->last_mouse_motion_frame, or
              gui_redo_mouse_highlight will end up highlighting the
-             last known poisition of the mouse if a tooltip frame is
+             last known position of the mouse if a tooltip frame is
              later unmapped.  */
 
           if (f == dpyinfo->last_mouse_motion_frame)
@@ -18885,13 +19582,20 @@ handle_one_xevent (struct x_display_info *dpyinfo,
           if (configureEvent.xconfigure.width != dpyinfo->screen_width
               || configureEvent.xconfigure.height != dpyinfo->screen_height)
             {
-              inev.ie.kind = MONITORS_CHANGED_EVENT;
-              XSETTERMINAL (inev.ie.arg, dpyinfo->terminal);
+              /* Also avoid storing duplicate events here, since
+                 Fx_display_monitor_attributes_list will return the
+                 same information for both invocations of the
+                 hook.  */
+              if (!x_find_monitors_changed_event (dpyinfo))
+                {
+                  inev.ie.kind = MONITORS_CHANGED_EVENT;
+                  XSETTERMINAL (inev.ie.arg, dpyinfo->terminal);
 
-              /* Store this event now since inev.ie.type could be set to
-                 MOVE_FRAME_EVENT later.  */
-              kbd_buffer_store_event (&inev.ie);
-              inev.ie.kind = NO_EVENT;
+                  /* Store this event now since inev.ie.type could be set to
+                     MOVE_FRAME_EVENT later.  */
+                  kbd_buffer_store_event (&inev.ie);
+                  inev.ie.kind = NO_EVENT;
+                }
 
               /* Also update the position of the drag-and-drop
                  tooltip.  */
@@ -19663,11 +20367,11 @@ handle_one_xevent (struct x_display_info *dpyinfo,
           {
           case XI_FocusIn:
             {
-              XIFocusInEvent *focusin = (XIFocusInEvent *) xi_event;
-              struct xi_device_t *source;
+              XIFocusInEvent *focusin;
 
+              focusin = (XIFocusInEvent *) xi_event;
               any = x_any_window_to_frame (dpyinfo, focusin->event);
-              source = xi_device_from_id (dpyinfo, focusin->sourceid);
+
 #ifdef USE_GTK
               /* Some WMs (e.g. Mutter in Gnome Shell), don't unmap
                  minimized/iconified windows; thus, for those WMs we won't get
@@ -19696,24 +20400,19 @@ handle_one_xevent (struct x_display_info *dpyinfo,
                     }
                 }
 
-              x_detect_focus_change (dpyinfo, any, event, &inev.ie);
+              xi_focus_handle_for_device (dpyinfo, any, xi_event);
 
-              if (inev.ie.kind != NO_EVENT && source)
-                inev.ie.device = source->name;
               goto XI_OTHER;
             }
 
           case XI_FocusOut:
             {
-              XIFocusOutEvent *focusout = (XIFocusOutEvent *) xi_event;
-              struct xi_device_t *source;
+              XIFocusOutEvent *focusout;
 
+              focusout = (XIFocusOutEvent *) xi_event;
               any = x_any_window_to_frame (dpyinfo, focusout->event);
-              source = xi_device_from_id (dpyinfo, focusout->sourceid);
-              x_detect_focus_change (dpyinfo, any, event, &inev.ie);
+              xi_focus_handle_for_device (dpyinfo, any, xi_event);
 
-              if (inev.ie.kind != NO_EVENT && source)
-                inev.ie.device = source->name;
               goto XI_OTHER;
             }
 
@@ -19762,7 +20461,7 @@ handle_one_xevent (struct x_display_info *dpyinfo,
                  are an inferiors of the frame's top window, which will
                  get virtual events.  */
               if (any)
-                x_detect_focus_change (dpyinfo, any, event, &inev.ie);
+                xi_focus_handle_for_device (dpyinfo, any, xi_event);
 
               if (!any)
                 any = x_any_window_to_frame (dpyinfo, enter->event);
@@ -19902,7 +20601,7 @@ handle_one_xevent (struct x_display_info *dpyinfo,
 #endif
 
               if (any)
-                x_detect_focus_change (dpyinfo, any, event, &inev.ie);
+                xi_focus_handle_for_device (dpyinfo, any, xi_event);
 
 #ifndef USE_X_TOOLKIT
               f = x_top_window_to_frame (dpyinfo, leave->event);
@@ -19929,7 +20628,7 @@ handle_one_xevent (struct x_display_info *dpyinfo,
                 {
                   /* Now clear dpyinfo->last_mouse_motion_frame, or
                      gui_redo_mouse_highlight will end up highlighting
-                     the last known poisition of the mouse if a
+                     the last known position of the mouse if a
                      tooltip frame is later unmapped.  */
 
                   if (f == dpyinfo->last_mouse_motion_frame)
@@ -20590,7 +21289,15 @@ handle_one_xevent (struct x_display_info *dpyinfo,
                  has changed, generate a HELP_EVENT.  */
               if (!NILP (help_echo_string)
                   || !NILP (previous_help_echo_string))
-                do_help = 1;
+                {
+                  /* Also allow the focus and client pointer to be
+                     adjusted accordingly, in case a help tooltip is
+                     shown.  */
+                  gen_help_device = device;
+                  gen_help_time = xev->time;
+
+                  do_help = 1;
+                }
               goto XI_OTHER;
             }
 
@@ -20653,6 +21360,10 @@ handle_one_xevent (struct x_display_info *dpyinfo,
                     }
 #endif
 
+                  if (f && device)
+                    xi_handle_interaction (dpyinfo, f, device,
+                                           xev->time);
+
                   if (xev->evtype == XI_ButtonPress
                       && x_dnd_last_seen_window != None)
                     {
@@ -20899,11 +21610,19 @@ handle_one_xevent (struct x_display_info *dpyinfo,
                                               xev->send_event);
 
               source = xi_device_from_id (dpyinfo, xev->sourceid);
+              device = xi_device_from_id (dpyinfo, xev->deviceid);
 
 #ifdef HAVE_XWIDGETS
               xvw = xwidget_view_from_window (xev->event);
               if (xvw)
                 {
+                  /* If the user interacts with a frame that's focused
+                     on another device, but not the current focus
+                     frame, make it the focus frame.  */
+                  if (device)
+                    xi_handle_interaction (dpyinfo, xvw->frame,
+                                           device, xev->time);
+
                   xwidget_button (xvw, xev->evtype == XI_ButtonPress,
                                   lrint (xev->event_x), lrint (xev->event_y),
                                   xev->detail, xi_convert_event_state (xev),
@@ -20923,8 +21642,6 @@ handle_one_xevent (struct x_display_info *dpyinfo,
                 }
 #endif
 
-              device = xi_device_from_id (dpyinfo, xev->deviceid);
-
               if (!device)
                 goto XI_OTHER;
 
@@ -20962,6 +21679,16 @@ handle_one_xevent (struct x_display_info *dpyinfo,
                     }
                 }
 
+              if (f)
+                {
+                  /* If the user interacts with a frame that's focused
+                     on another device, but not the current focus
+                     frame, make it the focus frame.  */
+                  if (device)
+                    xi_handle_interaction (dpyinfo, f, device,
+                                           xev->time);
+                }
+
 #ifdef USE_GTK
               if (!f)
                 {
@@ -21243,6 +21970,25 @@ handle_one_xevent (struct x_display_info *dpyinfo,
 
               f = x_any_window_to_frame (dpyinfo, xev->event);
 
+              /* GTK handles TAB events in an undesirable manner, so
+                 keyboard events are always dropped.  But as a side
+                 effect, the user time will no longer be set by GDK,
+                 so do that manually.  */
+#ifdef USE_GTK
+              if (f)
+                x_set_gtk_user_time (f, xev->time);
+#endif
+
+              if (f)
+                {
+                  /* If the user interacts with a frame that's focused
+                     on another device, but not the current focus
+                     frame, make it the focus frame.  */
+                  if (device)
+                    xi_handle_interaction (dpyinfo, f, device,
+                                           xev->time);
+                }
+
               XKeyPressedEvent xkey;
 
               memset (&xkey, 0, sizeof xkey);
@@ -21717,14 +22463,14 @@ handle_one_xevent (struct x_display_info *dpyinfo,
 
           case XI_HierarchyChanged:
             {
-              XIHierarchyEvent *hev = (XIHierarchyEvent *) xi_event;
+              XIHierarchyEvent *hev;
               XIDeviceInfo *info;
-              int i, j, ndevices, n_disabled, *disabled;
-              struct xi_device_t *device, *devices;
-#ifdef HAVE_XINPUT2_2
-              struct xi_touch_point_t *tem, *last;
-#endif
+              int i, ndevices, n_disabled, *disabled;
+              struct xi_device_t *device;
+              bool any_changed;
 
+              any_changed = false;
+              hev = (XIHierarchyEvent *) xi_event;
               disabled = SAFE_ALLOCA (sizeof *disabled * hev->num_info);
               n_disabled = 0;
 
@@ -21734,44 +22480,16 @@ handle_one_xevent (struct x_display_info *dpyinfo,
                     {
                       /* Handle all disabled devices now, to prevent
                          things happening out-of-order later.  */
-                      if (n_disabled)
-                        {
-                          ndevices = 0;
-                          devices = xmalloc (sizeof *devices * dpyinfo->num_devices);
-
-                          for (i = 0; i < dpyinfo->num_devices; ++i)
-                            {
-                              for (j = 0; j < n_disabled; ++j)
-                                {
-                                  if (disabled[j] == dpyinfo->devices[i].device_id)
-                                    {
-#ifdef HAVE_XINPUT2_1
-                                      xfree (dpyinfo->devices[i].valuators);
-#endif
-#ifdef HAVE_XINPUT2_2
-                                      tem = dpyinfo->devices[i].touchpoints;
-                                      while (tem)
-                                        {
-                                          last = tem;
-                                          tem = tem->next;
-                                          xfree (last);
-                                        }
-#endif
-                                      goto continue_detachment;
-                                    }
-                                }
-
-                              devices[ndevices++] = dpyinfo->devices[i];
-
-                            continue_detachment:
-                              continue;
-                            }
-
-                          xfree (dpyinfo->devices);
-                          dpyinfo->devices = devices;
-                          dpyinfo->num_devices = ndevices;
 
+                      if (ndevices)
+                        {
+                          xi_disable_devices (dpyinfo, disabled, n_disabled);
                           n_disabled = 0;
+
+                          /* This flag really just means that disabled
+                             devices were handled early and should be
+                             used in conjunction with n_disabled.  */
+                          any_changed = true;
                         }
 
                       x_catch_errors (dpyinfo->display);
@@ -21784,6 +22502,8 @@ handle_one_xevent (struct x_display_info *dpyinfo,
                           dpyinfo->devices
                             = xrealloc (dpyinfo->devices, (sizeof *dpyinfo->devices
                                                            * ++dpyinfo->num_devices));
+                          memset (dpyinfo->devices + dpyinfo->num_devices - 1,
+                                  0, sizeof *dpyinfo->devices);
                           device = &dpyinfo->devices[dpyinfo->num_devices - 1];
                           xi_populate_device_from_info (device, info);
                         }
@@ -21805,7 +22525,10 @@ handle_one_xevent (struct x_display_info *dpyinfo,
                       if (info)
                         {
                           if (device && info->enabled)
-                            device->use = info->use;
+                            {
+                              device->use = info->use;
+                              device->attachment = info->attachment;
+                            }
                           else if (device)
                             disabled[n_disabled++] = hev->info[i].deviceid;
 
@@ -21814,174 +22537,37 @@ handle_one_xevent (struct x_display_info *dpyinfo,
                     }
                 }
 
-              if (n_disabled)
-                {
-                  ndevices = 0;
-                  devices = xmalloc (sizeof *devices * dpyinfo->num_devices);
-
-                  for (i = 0; i < dpyinfo->num_devices; ++i)
-                    {
-                      for (j = 0; j < n_disabled; ++j)
-                        {
-                          if (disabled[j] == dpyinfo->devices[i].device_id)
-                            {
-#ifdef HAVE_XINPUT2_1
-                              xfree (dpyinfo->devices[i].valuators);
-#endif
-#ifdef HAVE_XINPUT2_2
-                              tem = dpyinfo->devices[i].touchpoints;
-                              while (tem)
-                                {
-                                  last = tem;
-                                  tem = tem->next;
-                                  xfree (last);
-                                }
-#endif
-                              goto break_detachment;
-                            }
-                        }
-
-                      devices[ndevices++] = dpyinfo->devices[i];
-
-                    break_detachment:
-                      continue;
-                    }
+              /* Delete all devices that were disabled by this
+                 event.  */
+              xi_disable_devices (dpyinfo, disabled, n_disabled);
 
-                  xfree (dpyinfo->devices);
-                  dpyinfo->devices = devices;
-                  dpyinfo->num_devices = ndevices;
-                }
+              /* If the device hierarchy has been changed, recompute
+                 focus.  This might seem like a micro-optimization but
+                 it actually keeps the focus from changing in some
+                 cases where it would be undesierable.  */
+              if (any_changed || n_disabled)
+                xi_handle_focus_change (dpyinfo);
 
               goto XI_OTHER;
             }
 
           case XI_DeviceChanged:
             {
-              XIDeviceChangedEvent *device_changed = (XIDeviceChangedEvent *) xi_event;
+              XIDeviceChangedEvent *device_changed;
               struct xi_device_t *device;
-#ifdef HAVE_XINPUT2_2
-              struct xi_touch_point_t *tem, *last;
-#endif
-              int c;
-#ifdef HAVE_XINPUT2_1
-              int i;
-#endif
 
+              device_changed = (XIDeviceChangedEvent *) xi_event;
               device = xi_device_from_id (dpyinfo, device_changed->deviceid);
 
-              if (!device)
-                {
-                  /* An existing device might have been enabled.  */
-                  x_cache_xi_devices (dpyinfo);
-
-                  /* Now try to find the device again, in case it was
-                     just enabled.  */
-                  device = xi_device_from_id (dpyinfo, device_changed->deviceid);
-                }
-
-              /* If it wasn't enabled, then stop handling this event.  */
+              /* If the device isn't enabled, then stop handling this
+                 event.  A HierarchyChanged event will be sent if it
+                 is enabled afterwards.  */
               if (!device)
                 goto XI_OTHER;
 
-              /* Free data that we will regenerate from new
-                 information.  */
-#ifdef HAVE_XINPUT2_1
-              device->valuators = xrealloc (device->valuators,
-                                            (device_changed->num_classes
-                                             * sizeof *device->valuators));
-              device->scroll_valuator_count = 0;
-#endif
-#ifdef HAVE_XINPUT2_2
-              device->direct_p = false;
-#endif
-
-              for (c = 0; c < device_changed->num_classes; ++c)
-                {
-                  switch (device_changed->classes[c]->type)
-                    {
-#ifdef HAVE_XINPUT2_1
-                    case XIScrollClass:
-                      {
-                        XIScrollClassInfo *info;
-
-                        info = (XIScrollClassInfo *) device_changed->classes[c];
-                        struct xi_scroll_valuator_t *valuator;
-
-                        valuator = &device->valuators[device->scroll_valuator_count++];
-                        valuator->horizontal
-                          = (info->scroll_type == XIScrollTypeHorizontal);
-                        valuator->invalid_p = true;
-                        valuator->emacs_value = DBL_MIN;
-                        valuator->increment = info->increment;
-                        valuator->number = info->number;
-
-                        break;
-                      }
-#endif
-
-#ifdef HAVE_XINPUT2_2
-                    case XITouchClass:
-                      {
-                        XITouchClassInfo *info;
-
-                        info = (XITouchClassInfo *) device_changed->classes[c];
-                        device->direct_p = info->mode == XIDirectTouch;
-                      }
-#endif
-                    default:
-                      break;
-                    }
-                }
-
-#ifdef HAVE_XINPUT2_1
-              for (c = 0; c < device_changed->num_classes; ++c)
-                {
-                  if (device_changed->classes[c]->type == XIValuatorClass)
-                    {
-                      XIValuatorClassInfo *info;
-
-                      info = (XIValuatorClassInfo *) device_changed->classes[c];
-
-                      for (i = 0; i < device->scroll_valuator_count; ++i)
-                        {
-                          if (device->valuators[i].number == info->number)
-                            {
-                              device->valuators[i].invalid_p = false;
-                              device->valuators[i].current_value = info->value;
-
-                              /* Make sure that this is reset if the
-                                 pointer moves into a window of ours.
-
-                                 Otherwise the valuator state could be
-                                 left invalid if the DeviceChange
-                                 event happened with the pointer
-                                 outside any Emacs frame. */
-                              device->valuators[i].pending_enter_reset = true;
-                            }
-                        }
-                    }
-                }
-#endif
-
-#ifdef HAVE_XINPUT2_2
-              /* The device is no longer a DirectTouch device, so
-                 remove any touchpoints that we might have
-                 recorded.  */
-              if (!device->direct_p)
-                {
-                  tem = device->touchpoints;
-
-                  while (tem)
-                    {
-                      last = tem;
-                      tem = tem->next;
-                      xfree (last);
-                    }
-
-                  device->touchpoints = NULL;
-                }
-#endif
-
+              /* Now handle the event by retrieving scroll valuators
+                 and touch info.  */
+              xi_handle_device_changed (dpyinfo, device, device_changed);
               goto XI_OTHER;
             }
 
@@ -22533,7 +23119,6 @@ handle_one_xevent (struct x_display_info *dpyinfo,
               || event->type == (dpyinfo->xrandr_event_base
                                  + RRNotify)))
         {
-          union buffered_input_event *ev;
           Time timestamp;
           Lisp_Object current_monitors;
           XRRScreenChangeNotifyEvent *notify;
@@ -22561,13 +23146,7 @@ handle_one_xevent (struct x_display_info *dpyinfo,
           else
             timestamp = 0;
 
-          ev = (kbd_store_ptr == kbd_buffer
-                ? kbd_buffer + KBD_BUFFER_SIZE - 1
-                : kbd_store_ptr - 1);
-
-          if (kbd_store_ptr != kbd_fetch_ptr
-              && ev->ie.kind == MONITORS_CHANGED_EVENT
-              && XTERMINAL (ev->ie.arg) == dpyinfo->terminal)
+          if (x_find_monitors_changed_event (dpyinfo))
             /* Don't store a MONITORS_CHANGED_EVENT if there is
                already an undelivered event on the queue.  */
             goto OTHER;
@@ -22655,6 +23234,12 @@ handle_one_xevent (struct x_display_info *dpyinfo,
       if (do_help > 0)
         {
           any_help_event_p = true;
+#ifdef HAVE_XINPUT2
+          if (gen_help_device)
+            xi_handle_interaction (dpyinfo, f,
+                                   gen_help_device,
+                                   gen_help_time);
+#endif
           gen_help_event (help_echo_string, frame, help_echo_window,
                           help_echo_object, help_echo_pos);
         }
@@ -23132,8 +23717,6 @@ x_draw_window_cursor (struct window *w, struct glyph_row *glyph_row, int x,
         xic_set_preeditarea (w, x, y);
 #endif
     }
-
-  XFlush (FRAME_X_DISPLAY (f));
 }
 
 
@@ -25648,6 +26231,7 @@ x_make_frame_visible (struct frame *f)
   struct x_display_info *dpyinfo;
   struct x_output *output;
 #endif
+  bool output_flushed;
 
   if (FRAME_PARENT_FRAME (f))
     {
@@ -25738,8 +26322,6 @@ x_make_frame_visible (struct frame *f)
         }
     }
 
-  XFlush (FRAME_X_DISPLAY (f));
-
   /* Synchronize to ensure Emacs knows the frame is visible
      before we do anything else.  We do this loop with input not blocked
      so that incoming events are handled.  */
@@ -25758,6 +26340,10 @@ x_make_frame_visible (struct frame *f)
     /* This must come after we set COUNT.  */
     unblock_input ();
 
+    /* Keep track of whether or not the output buffer was flushed, to
+       avoid any extra flushes.  */
+    output_flushed = false;
+
     /* We unblock here so that arriving X events are processed.  */
 
     /* Now move the window back to where it was "supposed to be".
@@ -25791,6 +26377,7 @@ x_make_frame_visible (struct frame *f)
            there, and take the potential window manager hit.  */
         XGetGeometry (FRAME_X_DISPLAY (f), FRAME_OUTER_WINDOW (f),
                       &rootw, &x, &y, &width, &height, &border, &depth);
+        output_flushed = true;
 
         if (original_left != x || original_top != y)
           XMoveWindow (FRAME_X_DISPLAY (f), FRAME_OUTER_WINDOW (f),
@@ -25825,7 +26412,11 @@ x_make_frame_visible (struct frame *f)
             (f, build_string ("x_make_frame_visible"));
 
         x_wait_for_event (f, MapNotify);
+        output_flushed = true;
       }
+
+    if (!output_flushed)
+      x_flush (f);
   }
 }
 
@@ -26045,6 +26636,11 @@ x_free_frame_resources (struct frame *f)
 
   block_input ();
 
+#ifdef HAVE_XINPUT2
+  /* Remove any record of this frame being focused.  */
+  xi_handle_delete_frame (dpyinfo, f);
+#endif
+
   /* If a display connection is dead, don't try sending more
      commands to the X server.  */
   if (dpyinfo->display)
@@ -26192,7 +26788,10 @@ x_free_frame_resources (struct frame *f)
       if (f->output_data.x->bottom_left_corner_cursor != 0)
         XFreeCursor (FRAME_X_DISPLAY (f), f->output_data.x->bottom_left_corner_cursor);
 
-      XFlush (FRAME_X_DISPLAY (f));
+      /* Free sync fences.  */
+#if defined HAVE_XSYNCTRIGGERFENCE && !defined USE_GTK
+      x_sync_free_fences (f);
+#endif
     }
 
 #ifdef HAVE_GTK3
@@ -27416,6 +28015,8 @@ x_term_init (Lisp_Object display_name, char *xrm_option, char *resource_name)
   int minor = 0;
 #endif
 
+  dpyinfo->client_pointer_device = -1;
+
   if (XQueryExtension (dpyinfo->display, "XInputExtension",
                        &dpyinfo->xi2_opcode, &xi_first_event,
                        &xi_first_error))
diff --git a/src/xterm.h b/src/xterm.h
index 2b8a2e5da49..e97f3d4c831 100644
--- a/src/xterm.h
+++ b/src/xterm.h
@@ -238,23 +238,54 @@ struct xi_touch_point_t
 
 struct xi_device_t
 {
+  /* The numerical ID of this device.  */
   int device_id;
+
 #ifdef HAVE_XINPUT2_1
+  /* The number of scroll valuators in `valuators'.  */
   int scroll_valuator_count;
 #endif
+
+  /* Whether or not the device is grabbed and its use.  */
   int grab, use;
+
+  /* The attached device.  Only valid if USE is some kind of master
+     device.  */
+  int attachment;
+
 #ifdef HAVE_XINPUT2_2
+  /* Whether or not this device is a direct touch device.  */
   bool direct_p;
 #endif
 
 #ifdef HAVE_XINPUT2_1
+  /* An array of scroll valuators Emacs knows about.  */
   struct xi_scroll_valuator_t *valuators;
 #endif
+
 #ifdef HAVE_XINPUT2_2
+  /* An array of in-progress touchscreen events.  */
   struct xi_touch_point_t *touchpoints;
 #endif
 
+  /* The name of this device.  */
   Lisp_Object name;
+
+  /* The time at which `focus_frame' became the keyboard focus (only
+     applies to master devices).  */
+  Time focus_frame_time;
+
+  /* The frame that is currently this device's keyboard focus, or
+     NULL.  */
+  struct frame *focus_frame;
+
+  /* The time at which `focus_frame' became the implicit keyboard
+     focus.  */
+  Time focus_implicit_time;
+
+  /* The frame that is currently this device's implicit keyboard
+     focus, or NULL.  */
+  struct frame *focus_implicit_frame;
 };
 #endif
 
@@ -482,7 +513,10 @@ struct x_display_info
   /* The last frame mentioned in a FocusIn or FocusOut event.  This is
      separate from x_focus_frame, because whether or not LeaveNotify
      events cause us to lose focus depends on whether or not we have
-     received a FocusIn event for it.  */
+     received a FocusIn event for it.
+
+     This field is not used when the input extension is being
+     utilized.  */
   struct frame *x_focus_event_frame;
 
   /* The frame which currently has the visual highlight, and should get
@@ -614,9 +648,9 @@ struct x_display_info
     Xatom_net_wm_state_shaded, Xatom_net_frame_extents, Xatom_net_current_desktop,
     Xatom_net_workarea, Xatom_net_wm_opaque_region, Xatom_net_wm_ping,
     Xatom_net_wm_sync_request, Xatom_net_wm_sync_request_counter,
-    Xatom_net_wm_frame_drawn, Xatom_net_wm_frame_timings, Xatom_net_wm_user_time,
-    Xatom_net_wm_user_time_window, Xatom_net_client_list_stacking,
-    Xatom_net_wm_pid;
+    Xatom_net_wm_sync_fences, Xatom_net_wm_frame_drawn, Xatom_net_wm_frame_timings,
+    Xatom_net_wm_user_time, Xatom_net_wm_user_time_window,
+    Xatom_net_client_list_stacking, Xatom_net_wm_pid;
 
   /* XSettings atoms and windows.  */
   Atom Xatom_xsettings_sel, Xatom_xsettings_prop, Xatom_xsettings_mgr;
@@ -678,13 +712,27 @@ struct x_display_info
 
 #ifdef HAVE_XINPUT2
   bool supports_xi2;
+
+  /* The minor version of the input extension.  (Major is always
+     2.x.) */
   int xi2_version;
+
+  /* The generic event opcode of XI2 events.  */
   int xi2_opcode;
 
+  /* The number of devices on this display known to Emacs.  */
   int num_devices;
+
+  /* Array of all input extension devices on this display known to
+     Emacs.  */
   struct xi_device_t *devices;
 
+  /* Pending keystroke time.  */
   Time pending_keystroke_time;
+
+  /* Pending keystroke source.  If a core KeyPress event arrives with
+     the same timestamp as pending_keystroke_time, it will be treated
+     as originating from this device.  */
   int pending_keystroke_source;
 
 #if defined USE_GTK && !defined HAVE_GTK3
@@ -694,6 +742,10 @@ struct x_display_info
      input method) core key event.  */
   bool pending_keystroke_time_special_p;
 #endif
+
+  /* The client pointer.  We keep a record client-side to avoid
+     calling XISetClientPointer all the time.  */
+  int client_pointer_device;
 #endif
 
 #ifdef HAVE_XKB
@@ -769,6 +821,16 @@ struct x_display_info
   /* The pending drag-and-drop time for middle-click based
      drag-and-drop emulation.  */
   Time pending_dnd_time;
+
+#if defined HAVE_XSYNC && !defined USE_GTK
+  /* Whether or not the server time is probably the same as
+     "clock_gettime (CLOCK_MONOTONIC, ...)".  */
+  bool server_time_monotonic_p;
+
+  /* The time difference between the X server clock and the monotonic
+     clock.  */
+  int64_t server_time_offset;
+#endif
 };
 
 #ifdef HAVE_X_I18N
@@ -1061,6 +1123,19 @@ struct x_output
   /* Whether or not Emacs should wait for the compositing manager to
      draw frames before starting a new frame.  */
   bool_bf use_vsync_p : 1;
+
+  /* The time (in microseconds) it took to draw the last frame.  */
+  uint64_t last_frame_time;
+
+  /* A temporary time used to calculate that value.  */
+  uint64_t temp_frame_time;
+
+#ifdef HAVE_XSYNCTRIGGERFENCE
+  /* An array of two sync fences that are triggered in order after a
+     frame completes.  Not initialized if the XSync extension is too
+     old to support sync fences.  */
+  XSyncFence sync_fences[2];
+#endif
 #endif
 #endif
 
@@ -1078,7 +1153,9 @@ struct x_output
 
   /* Keep track of focus.  May be EXPLICIT if we received a FocusIn for this
      frame, or IMPLICIT if we received an EnterNotify.
-     FocusOut and LeaveNotify clears EXPLICIT/IMPLICIT. */
+     FocusOut and LeaveNotify clears EXPLICIT/IMPLICIT.
+
+     Not used when the input extension is being utilized.  */
   int focus_state;
 
   /* The offset we need to add to compensate for type A WMs.  */
@@ -1500,6 +1577,9 @@ extern void x_make_frame_invisible (struct frame *);
 extern void x_iconify_frame (struct frame *);
 extern void x_free_frame_resources (struct frame *);
 extern void x_wm_set_size_hint (struct frame *, long, bool);
+#if defined HAVE_XSYNCTRIGGERFENCE && !defined USE_GTK
+extern void x_sync_init_fences (struct frame *);
+#endif
 
 extern void x_delete_terminal (struct terminal *);
 extern Cursor x_create_font_cursor (struct x_display_info *, int);
@@ -1541,11 +1621,14 @@ extern Lisp_Object x_cr_export_frames (Lisp_Object, cairo_surface_type_t);
 #ifdef HAVE_XRENDER
 extern void x_xrender_color_from_gc_background (struct frame *, GC,
                                                 XRenderColor *, bool);
-extern void x_xr_ensure_picture (struct frame *f);
-extern void x_xr_apply_ext_clip (struct frame *f, GC gc);
-extern void x_xr_reset_ext_clip (struct frame *f);
+extern void x_xr_ensure_picture (struct frame *);
+extern void x_xr_apply_ext_clip (struct frame *, GC);
+extern void x_xr_reset_ext_clip (struct frame *);
 #endif
 
+extern Bool x_query_pointer (Display *, Window, Window *, Window *, int *,
+                             int *, int *, int *, unsigned int *);
+
 #ifdef HAVE_GTK3
 extern void x_scroll_bar_configure (GdkEvent *);
 #endif