upstream

36 files changed, 1000 insertions, 724 deletions

diff --git a/src/.gdbinit b/src/.gdbinit
index 952d7392a4c..fa580cc99bf 100644
--- a/src/.gdbinit
+++ b/src/.gdbinit
@@ -650,19 +650,52 @@ If the first type printed is Lisp_Vector or Lisp_Misc,
 a second line gives the more precise type.
 end
 
+define pvectype
+  set $size = ((struct Lisp_Vector *) $arg0)->header.size
+  if ($size & PSEUDOVECTOR_FLAG)
+    output (enum pvec_type) (($size & PVEC_TYPE_MASK) >> PSEUDOVECTOR_AREA_BITS)
+  else
+    output PVEC_NORMAL_VECTOR
+  end
+  echo \n
+end
+document pvectype
+Print the subtype of vectorlike object.
+Takes one argument, a pointer to an object.
+end
+
 define xvectype
   xgetptr $
-  set $size = ((struct Lisp_Vector *) $ptr)->header.size
+  pvectype $ptr
+end
+document xvectype
+Print the subtype of vectorlike object.
+This command assumes that $ is a Lisp_Object.
+end
+
+define pvecsize
+  set $size = ((struct Lisp_Vector *) $arg0)->header.size
   if ($size & PSEUDOVECTOR_FLAG)
-    output (enum pvec_type) (($size & PVEC_TYPE_MASK) >> PSEUDOVECTOR_SIZE_BITS)
+    output ($size & PSEUDOVECTOR_SIZE_MASK)
+    echo \n
+    output (($size & PSEUDOVECTOR_REST_MASK) >> PSEUDOVECTOR_SIZE_BITS)
   else
-    output $size & ~ARRAY_MARK_FLAG
+    output ($size & ~ARRAY_MARK_FLAG)
   end
   echo \n
 end
-document xvectype
-Print the size or vector subtype of $.
-This command assumes that $ is a vector or pseudovector.
+document pvecsize
+Print the size of vectorlike object.
+Takes one argument, a pointer to an object.
+end
+
+define xvecsize
+  xgetptr $
+  pvecsize $ptr
+end
+document xvecsize
+Print the size of $
+This command assumes that $ is a Lisp_Object.
 end
 
 define xmisctype
@@ -996,7 +1029,7 @@ define xpr
   if $type == Lisp_Vectorlike
     set $size = ((struct Lisp_Vector *) $ptr)->header.size
     if ($size & PSEUDOVECTOR_FLAG)
-      set $vec = (enum pvec_type) (($size & PVEC_TYPE_MASK) >> PSEUDOVECTOR_SIZE_BITS)
+      set $vec = (enum pvec_type) (($size & PVEC_TYPE_MASK) >> PSEUDOVECTOR_AREA_BITS)
       if $vec == PVEC_NORMAL_VECTOR
         xvector
       end
@@ -1132,7 +1165,7 @@ define xbacktrace
         xgetptr ($bt->function)
         set $size = ((struct Lisp_Vector *) $ptr)->header.size
         if ($size & PSEUDOVECTOR_FLAG)
-          output (enum pvec_type) (($size & PVEC_TYPE_MASK) >> PSEUDOVECTOR_SIZE_BITS)
+          output (enum pvec_type) (($size & PVEC_TYPE_MASK) >> PSEUDOVECTOR_AREA_BITS)
         else
           output $size & ~ARRAY_MARK_FLAG
         end
diff --git a/src/ChangeLog b/src/ChangeLog
index 0eb69f59efe..5905c667852 100644
--- a/src/ChangeLog
+++ b/src/ChangeLog
@@ -1,3 +1,249 @@
+2012-11-13  Paul Eggert  <eggert@cs.ucla.edu>
+
+        Fix a race with verify-visited-file-modtime (Bug#12863).
+        Since at least 1991 Emacs has ignored an mtime difference of no
+        more than one second, but my guess is that this was to work around
+        file system bugs that were fixed long ago.  Since the race is
+        causing problems now, let's remove that code.
+        * fileio.c (Fverify_visited_file_modtime): Do not accept a file
+        whose time stamp is off by no more than a second.  Insist that the
+        file time stamps match exactly.
+
+2012-11-12  Dmitry Antipov  <dmantipov@yandex.ru>
+
+        * frame.h (struct frame): Convert external_tool_bar member to
+        1-bit unsigned bitfield.
+        * termhooks.h (struct terminal): Remove mouse_moved member since
+        all users are long dead.  Adjust comment on mouse_position_hook.
+
+2012-11-12  Dmitry Antipov  <dmantipov@yandex.ru>
+
+        Simplify by using FOR_EACH_FRAME here and there.
+        * frame.c (next_frame, prev_frame, other_visible_frames)
+        (delete_frame, visible-frame-list): Use FOR_EACH_FRAME.
+        * w32term.c (x_window_to_scroll_bar): Likewise.
+        * window.c (window_list): Likewise.
+        * xdisp.c (x_consider_frame_title): Likewise.
+        * xfaces.c ( Fdisplay_supports_face_attributes_p): Likewise.
+        * xfns.c (x_window_to_frame, x_any_window_to_frame)
+        (x_menubar_window_to_frame, x_top_window_to_frame): Likewise.
+        * xmenu.c (menubar_id_to_frame): Likewise.
+        * xselect.c (frame_for_x_selection): Likewise.
+        * xterm.c (x_frame_of_widget, x_window_to_scroll_bar)
+        (x_window_to_menu_bar): Likewise.
+        * w32fns.c (x_window_to_frame): Likewise.  Adjust comment.
+
+2012-11-12  Paul Eggert  <eggert@cs.ucla.edu>
+
+        * data.c (Qdefalias_fset_function): Now static.
+
+        Another tweak to vectorlike_header change.
+        * alloc.c (struct Lisp_Vectorlike_Free, NEXT_IN_FREE_LIST):
+        Remove, and replace all uses with ...
+        (next_in_free_list, set_next_in_free_list):
+        New functions, which respect C's aliasing rules better.
+
+2012-11-11  Paul Eggert  <eggert@cs.ucla.edu>
+
+        * window.c (list4i): Rename from 'quad'.  All uses changed.
+        Needed because <sys/types.h> defines 'quad' on Solaris 10.
+
+2012-11-11  Juanma Barranquero  <lekktu@gmail.com>
+
+        * xdisp.c (start_hourglass) [HAVE_NTGUI]: Add block to silence
+        warning about mixing declarations and code in ISO C90.
+
+2012-11-10  Martin Rudalics  <rudalics@gmx.at>
+
+        * window.c (Fsplit_window_internal): Set combination limit of
+        new parent window to t iff Vwindow_combination_limit is t;
+        fixing a regression introduced with the change from 2012-09-22.
+        (Fset_window_combination_limit): Fix doc-string.
+
+2012-11-10  Eli Zaretskii  <eliz@gnu.org>
+
+        * xdisp.c (try_scrolling): Fix correction of aggressive-scroll
+        amount when the scroll margins are too large.  When scrolling
+        backwards in the buffer, give up if cannot reach point or the
+        scroll margin within a reasonable number of screen lines.  Fixes
+        point position in window under scroll-up/down-aggressively when
+        point is positioned many lines beyond the window top/bottom.
+        (Bug#12811)
+
+        * ralloc.c (relinquish): If real_morecore fails to return memory
+        to the system, don't crash; instead, leave the last heap
+        unchanged and return.  (Bug#12774)
+
+2012-11-09  Stefan Monnier  <monnier@iro.umontreal.ca>
+
+        * lisp.h (AUTOLOADP): New macro.
+        * eval.c (Fautoload): Don't attach to loadhist, call Fdefalias instead.
+        * data.c (Ffset): Remove special ad-advice-info handling.
+        (Fdefalias): Handle autoload definitions and new Qdefalias_fset_function.
+        (Fsubr_arity): CSE.
+        (Finteractive_form): Simplify.
+        (Fquo): Don't insist on having at least 2 arguments.
+        (Qdefalias_fset_function): New var.
+
+2012-11-09  Jan Djärv  <jan.h.d@swipnet.se>
+
+        * image.c (xpm_make_color_table_h): Change to hashtest_equal.
+
+        * nsfont.m (Qcondensed, Qexpanded): New variables.
+        (ns_descriptor_to_entity): Restore Qcondensed, Qexpanded setting.
+        (syms_of_nsfont): Defsym Qcondensed, Qexpanded.
+
+2012-11-09  Dmitry Antipov  <dmantipov@yandex.ru>
+
+        Fix recently introduced crash on MS-Windows (Bug#12839).
+        * w32term.h (struct scroll_bar): Use convenient header.
+        (SCROLL_BAR_VEC_SIZE): Remove.
+        * w32term.c (x_scroll_bar_create): Use VECSIZE.
+
+2012-11-09  Dmitry Antipov  <dmantipov@yandex.ru>
+
+        Tweak last vectorlike_header change.
+        * alloc.c (struct Lisp_Vectorlike_Free): Special type to represent
+        vectorlike object on the free list.  This is introduced to avoid
+        some (but not all) pointer casting and aliasing problems, see
+        http://lists.gnu.org/archive/html/emacs-devel/2012-11/msg00105.html.
+        * .gdbinit (pvectype, pvecsize): New commands to examine vectorlike
+        objects.
+        (xvectype, xvecsize): Use them to examine Lisp_Object values.
+
+2012-11-09  Jan Djärv  <jan.h.d@swipnet.se>
+
+        * nsfont.m (ns_descriptor_to_entity): Qcondensed and Qexpanded has
+        been removed, so remove them here also.
+
+2012-11-09  Stefan Monnier  <monnier@iro.umontreal.ca>
+
+        * doc.c (Fdocumentation): Handle new property
+        dynamic-docstring-function to replace the old ad-advice-info.
+
+2012-11-09  Paul Eggert  <eggert@cs.ucla.edu>
+
+        * fns.c (Qeql, hashtest_eq): Now static.
+
+2012-11-08  Stefan Monnier  <monnier@iro.umontreal.ca>
+
+        * lisp.h (XHASH): Redefine to be imperfect and fit in a Lisp int.
+        * fns.c (hashfn_eq, hashfn_eql, sxhash):
+        * profiler.c (hashfn_profiler): Don't use XUINT on non-integers.
+        * buffer.c (compare_overlays): Use XLI rather than XHASH.
+
+2012-11-08  Paul Eggert  <eggert@cs.ucla.edu>
+
+        Use same hash function for hashfn_profiler as for hash_string etc.
+        * fns.c (SXHASH_COMBINE): Remove.  All uses replaced by sxhash_combine.
+        * lisp.h (sxhash_combine): New inline function, with the contents
+        of the old SXHASH_COMBINE.
+        * profiler.c (hashfn_profiler): Use it, instead of having a
+        special hash function containing a comparison that always yields 1.
+
+2012-11-08  Stefan Monnier  <monnier@iro.umontreal.ca>
+
+        * xfaces.c (Qultra_light, Qreverse_oblique, Qreverse_italic)
+        (Qultra_condensed, Qextra_condensed, Qcondensed, Qsemi_condensed)
+        (Qsemi_expanded, Qextra_expanded, Qexpanded, Qultra_expanded):
+        Remove unused vars.
+
+2012-11-08  Jan Djärv  <jan.h.d@swipnet.se>
+
+        * image.c (xpm_make_color_table_h): Fix compiler error because
+        make_hash_table changed.
+
+2012-11-08  Thomas Kappler <tkappler@gmail.com> (tiny change)
+
+        * nsfont.m (ns_findfonts): Handle empty matchingDescs (Bug#11541).
+
+2012-11-08  Stefan Monnier  <monnier@iro.umontreal.ca>
+
+        Use ad-hoc comparison function for the profiler's hash-tables.
+        * profiler.c (Qprofiler_backtrace_equal, hashtest_profiler): New vars.
+        (make_log): Use them.
+        (handle_profiler_signal): Don't inhibit quit any longer since we don't
+        call Fequal any more.
+        (Ffunction_equal): New function.
+        (cmpfn_profiler, hashfn_profiler): New functions.
+        (syms_of_profiler): Initialize them.
+        * lisp.h (struct hash_table_test): New struct.
+        (struct Lisp_Hash_Table): Use it.
+        * alloc.c (mark_object): Mark hash_table_test fields of hash tables.
+        * fns.c (make_hash_table): Take a struct to describe the test.
+        (cmpfn_eql, cmpfn_equal, cmpfn_user_defined, hashfn_eq, hashfn_eql)
+        (hashfn_equal, hashfn_user_defined): Adjust to new calling convention.
+        (hash_lookup, hash_remove_from_table): Move assertion checking of
+        hashfn result here.  Check hash-equality before calling cmpfn.
+        (Fmake_hash_table): Adjust call to make_hash_table.
+        (hashtest_eq, hashtest_eql, hashtest_equal): New structs.
+        (syms_of_fns): Initialize them.
+        * emacs.c (main): Move syms_of_fns earlier.
+        * xterm.c (syms_of_xterm):
+        * category.c (hash_get_category_set): Adjust call to make_hash_table.
+        * print.c (print_object): Adjust to new hash-table struct.
+        * composite.c (composition_gstring_put_cache): Adjust to new hashfn.
+
+2012-11-08  Eli Zaretskii  <eliz@gnu.org>
+
+        * w32fns.c (modifier_set): Fix handling of Scroll Lock when the
+        value of w32-scroll-lock-modifier is neither nil nor one of the
+        known key modifiers.  (Bug#12806)
+
+2012-11-08  Dmitry Antipov  <dmantipov@yandex.ru>
+
+        Shrink struct vectorlike_header to the only size field.
+        * lisp.h (enum pvec_type): Avoid explicit enum member values.
+        Adjust comment.
+        (enum More_Lisp_Bits): Change PSEUDOVECTOR_SIZE_BITS and
+        PVEC_TYPE_MASK to arrange new bitfield in the vector header.
+        (PSEUDOVECTOR_REST_BITS, PSEUDOVECTOR_REST_MASK): New members.
+        (PSEUDOVECTOR_AREA_BITS): New member used to extract subtype
+        information from the vector header.  Adjust comment.
+        (XSETPVECTYPE, XSETPVECTYPESIZE, XSETTYPED_PSEUDOVECTOR)
+        (PSEUDOVECTOR_TYPEP, DEFUN): Adjust to match new vector header
+        layout.
+        (XSETSUBR, SUBRP): Adjust to match new Lisp_Subr layout.
+        (struct vectorlike_header): Remove next member.  Adjust comment.
+        (struct Lisp_Subr): Add convenient header.  Adjust comment.
+        (allocate_pseudovector): Adjust prototype.
+        * alloc.c (mark_glyph_matrix, mark_face_cache, allocate_string)
+        (sweep_string, lisp_malloc): Remove useless prototypes.
+        (enum mem_type): Adjust comment.
+        (NEXT_IN_FREE_LIST): New macro.
+        (SETUP_ON_FREE_LIST): Adjust XSETPVECTYPESIZE usage.
+        (Fmake_bool_vector): Likewise.
+        (struct large_vector): New type to represent allocation unit for
+        the vectors with the memory footprint more than VBLOOCK_BYTES_MAX.
+        (large_vectors): Change type to struct large_vector.
+        (allocate_vector_from_block): Simplify.
+        (PSEUDOVECTOR_NBYTES): Replace with...
+        (vector_nbytes): ...new function.  Adjust users.
+        (sweep_vectors): Adjust processing of large vectors.
+        (allocate_vectorlike): Likewise.
+        (allocate_pseudovector): Change type of 3rd arg to enum pvec_type.
+        Add easserts.  Adjust XSETPVECTYPESIZE usage.
+        (allocate_buffer): Use BUFFER_PVEC_INIT.
+        (live_vector_p): Adjust to match large vector.
+        * buffer.c (init_buffer_once): Use BUFFER_PVEC_INIT.
+        * buffer.h (struct buffer): Add next member.
+        (BUFFER_LISP_SIZE, BUFFER_REST_SIZE, BUFFER_PVEC_INIT):
+        New macros.
+        (FOR_EACH_BUFFER): Adjust to match struct buffer change.
+        * fns.c (internal_equal): Adjust to match enum pvec_type change.
+        (copy_hash_table): Adjust to match vector header change.
+        * lread.c (defsubr): Use XSETPVECTYPE.
+        * .gdbinit (xpr, xbacktrace): Adjust to match vector header change.
+        (xvectype): Likewise.  Print PVEC_NORMAL_VECTOR for regular vectors.
+        (xvecsize): New command.
+
+2012-11-08  Dmitry Antipov  <dmantipov@yandex.ru>
+
+        * keyboard.c (event_to_kboard): Do not dereference
+        frame_or_window field of SELECTION_REQUEST_EVENT
+        and SELECTION_CLEAR_EVENT events (Bug#12814).
+        * xterm.h (struct selection_input_event): Adjust comment.
+
 2012-11-07  Eli Zaretskii  <eliz@gnu.org>
 
         * w32fns.c (modifier_set): Don't report modifiers from toggle key,
@@ -129,8 +375,8 @@
 
         Remove EMACS_OUTQSIZE+sleep hack.
         * dispnew.c (update_frame_1): Remove hack for terminals slower
-        than 2400 bps, which throttled Emacs by having it sleep.  This
-        code hasn't worked since at least 2007, when the multi-tty stuff
+        than 2400 bps, which throttled Emacs by having it sleep.
+        This code hasn't worked since at least 2007, when the multi-tty stuff
         was added, and anyway those old terminals are long dead.
         * systty.h (EMACS_OUTQSIZE): Remove; unused.  The macro isn't used even
         without the dispnew.c change, as dispnew.c doesn't include systty.h.
@@ -169,8 +415,8 @@
         waitpid only on subprocesses that Emacs itself creates.
         * process.c (create_process, record_child_status_change):
         Don't use special value -1 in pid field, as the caller now must
-        know the pid rather than having the callee infer it.  The
-        inference was sometimes incorrect anyway, due to another race.
+        know the pid rather than having the callee infer it.
+        The inference was sometimes incorrect anyway, due to another race.
         (create_process): Set new 'alive' member if child is created.
         (process_status_retrieved): New function.
         (record_child_status_change): Use it.
@@ -331,8 +577,8 @@
 
 2012-10-29  Daniel Colascione  <dancol@dancol.org>
 
-        * cygw32.h, cygw32.c (Qutf_16le, from_unicode, to_unicode): In
-        preparation for fixing bug#12739, move these functions from
+        * cygw32.h, cygw32.c (Qutf_16le, from_unicode, to_unicode):
+        In preparation for fixing bug#12739, move these functions from
         here...
 
         * coding.h, coding.c: ... to here, and compile them only when
diff --git a/src/alloc.c b/src/alloc.c
index 5bb528c64ab..a66a752f5dc 100644
--- a/src/alloc.c
+++ b/src/alloc.c
@@ -216,23 +216,19 @@ static Lisp_Object Qpost_gc_hook;
 static void mark_terminals (void);
 static void gc_sweep (void);
 static Lisp_Object make_pure_vector (ptrdiff_t);
-static void mark_glyph_matrix (struct glyph_matrix *);
-static void mark_face_cache (struct face_cache *);
 static void mark_buffer (struct buffer *);
 
 #if !defined REL_ALLOC || defined SYSTEM_MALLOC
 static void refill_memory_reserve (void);
 #endif
-static struct Lisp_String *allocate_string (void);
 static void compact_small_strings (void);
 static void free_large_strings (void);
-static void sweep_strings (void);
 static void free_misc (Lisp_Object);
 extern Lisp_Object which_symbols (Lisp_Object, EMACS_INT) EXTERNALLY_VISIBLE;
 
-/* When scanning the C stack for live Lisp objects, Emacs keeps track
-   of what memory allocated via lisp_malloc is intended for what
-   purpose.  This enumeration specifies the type of memory.  */
+/* When scanning the C stack for live Lisp objects, Emacs keeps track of
+   what memory allocated via lisp_malloc and lisp_align_malloc is intended
+   for what purpose.  This enumeration specifies the type of memory.  */
 
 enum mem_type
 {
@@ -243,10 +239,9 @@ enum mem_type
   MEM_TYPE_MISC,
   MEM_TYPE_SYMBOL,
   MEM_TYPE_FLOAT,
-  /* We used to keep separate mem_types for subtypes of vectors such as
-     process, hash_table, frame, terminal, and window, but we never made
-     use of the distinction, so it only caused source-code complexity
-     and runtime slowdown.  Minor but pointless.  */
+  /* Since all non-bool pseudovectors are small enough to be
+     allocated from vector blocks, this memory type denotes
+     large regular vectors and large bool pseudovectors.  */
   MEM_TYPE_VECTORLIKE,
   /* Special type to denote vector blocks.  */
   MEM_TYPE_VECTOR_BLOCK,
@@ -254,9 +249,6 @@ enum mem_type
   MEM_TYPE_SPARE
 };
 
-static void *lisp_malloc (size_t, enum mem_type);
-
-
 #if GC_MARK_STACK || defined GC_MALLOC_CHECK
 
 #if GC_MARK_STACK == GC_USE_GCPROS_CHECK_ZOMBIES
@@ -2040,7 +2032,7 @@ LENGTH must be a number.  INIT matters only in whether it is t or nil.  */)
   val = Fmake_vector (make_number (length_in_elts + extra_bool_elts), Qnil);
 
   /* No Lisp_Object to trace in there.  */
-  XSETPVECTYPESIZE (XVECTOR (val), PVEC_BOOL_VECTOR, 0);
+  XSETPVECTYPESIZE (XVECTOR (val), PVEC_BOOL_VECTOR, 0, 0);
 
   p = XBOOL_VECTOR (val);
   p->size = XFASTINT (length);
@@ -2619,19 +2611,54 @@ verify (VECTOR_BLOCK_SIZE <= (1 << PSEUDOVECTOR_SIZE_BITS));
 
 #define VINDEX(nbytes) (((nbytes) - VBLOCK_BYTES_MIN) / roundup_size)
 
+/* Get and set the next field in block-allocated vectorlike objects on
+   the free list.  Doing it this way respects C's aliasing rules.
+   We could instead make 'contents' a union, but that would mean
+   changes everywhere that the code uses 'contents'.  */
+static struct Lisp_Vector *
+next_in_free_list (struct Lisp_Vector *v)
+{
+  intptr_t i = XLI (v->contents[0]);
+  return (struct Lisp_Vector *) i;
+}
+static void
+set_next_in_free_list (struct Lisp_Vector *v, struct Lisp_Vector *next)
+{
+  v->contents[0] = XIL ((intptr_t) next);
+}
+
 /* Common shortcut to setup vector on a free list.  */
 
-#define SETUP_ON_FREE_LIST(v, nbytes, index)                    \
-  do {                                                          \
-    XSETPVECTYPESIZE (v, PVEC_FREE, nbytes);                    \
-    eassert ((nbytes) % roundup_size == 0);                     \
-    (index) = VINDEX (nbytes);                                  \
-    eassert ((index) < VECTOR_MAX_FREE_LIST_INDEX);             \
-    (v)->header.next.vector = vector_free_lists[index];         \
-    vector_free_lists[index] = (v);                             \
-    total_free_vector_slots += (nbytes) / word_size;            \
+#define SETUP_ON_FREE_LIST(v, nbytes, tmp)              \
+  do {                                                  \
+    (tmp) = ((nbytes - header_size) / word_size);       \
+    XSETPVECTYPESIZE (v, PVEC_FREE, 0, (tmp));          \
+    eassert ((nbytes) % roundup_size == 0);             \
+    (tmp) = VINDEX (nbytes);                            \
+    eassert ((tmp) < VECTOR_MAX_FREE_LIST_INDEX);       \
+    set_next_in_free_list (v, vector_free_lists[tmp]);  \
+    vector_free_lists[tmp] = (v);                       \
+    total_free_vector_slots += (nbytes) / word_size;    \
   } while (0)
 
+/* This internal type is used to maintain the list of large vectors
+   which are allocated at their own, e.g. outside of vector blocks.  */
+
+struct large_vector
+{
+  union {
+    struct large_vector *vector;
+#if USE_LSB_TAG
+    /* We need to maintain ROUNDUP_SIZE alignment for the vector member.  */
+    unsigned char c[vroundup (sizeof (struct large_vector *))];
+#endif
+  } next;
+  struct Lisp_Vector v;
+};
+
+/* This internal type is used to maintain an underlying storage
+   for small vectors.  */
+
 struct vector_block
 {
   char data[VECTOR_BLOCK_BYTES];
@@ -2649,7 +2676,7 @@ static struct Lisp_Vector *vector_free_lists[VECTOR_MAX_FREE_LIST_INDEX];
 
 /* Singly-linked list of large vectors.  */
 
-static struct Lisp_Vector *large_vectors;
+static struct large_vector *large_vectors;
 
 /* The only vector with 0 slots, allocated from pure space.  */
 
@@ -2693,7 +2720,7 @@ init_vectors (void)
 static struct Lisp_Vector *
 allocate_vector_from_block (size_t nbytes)
 {
-  struct Lisp_Vector *vector, *rest;
+  struct Lisp_Vector *vector;
   struct vector_block *block;
   size_t index, restbytes;
 
@@ -2706,8 +2733,7 @@ allocate_vector_from_block (size_t nbytes)
   if (vector_free_lists[index])
     {
       vector = vector_free_lists[index];
-      vector_free_lists[index] = vector->header.next.vector;
-      vector->header.next.nbytes = nbytes;
+      vector_free_lists[index] = next_in_free_list (vector);
       total_free_vector_slots -= nbytes / word_size;
       return vector;
     }
@@ -2721,16 +2747,14 @@ allocate_vector_from_block (size_t nbytes)
       {
         /* This vector is larger than requested.  */
         vector = vector_free_lists[index];
-        vector_free_lists[index] = vector->header.next.vector;
-        vector->header.next.nbytes = nbytes;
+        vector_free_lists[index] = next_in_free_list (vector);
         total_free_vector_slots -= nbytes / word_size;
 
         /* Excess bytes are used for the smaller vector,
            which should be set on an appropriate free list.  */
         restbytes = index * roundup_size + VBLOCK_BYTES_MIN - nbytes;
         eassert (restbytes % roundup_size == 0);
-        rest = ADVANCE (vector, nbytes);
-        SETUP_ON_FREE_LIST (rest, restbytes, index);
+        SETUP_ON_FREE_LIST (ADVANCE (vector, nbytes), restbytes, index);
         return vector;
       }
 
@@ -2739,7 +2763,6 @@ allocate_vector_from_block (size_t nbytes)
 
   /* New vector will be at the beginning of this block.  */
   vector = (struct Lisp_Vector *) block->data;
-  vector->header.next.nbytes = nbytes;
 
   /* If the rest of space from this block is large enough
      for one-slot vector at least, set up it on a free list.  */
@@ -2747,11 +2770,10 @@ allocate_vector_from_block (size_t nbytes)
   if (restbytes >= VBLOCK_BYTES_MIN)
     {
       eassert (restbytes % roundup_size == 0);
-      rest = ADVANCE (vector, nbytes);
-      SETUP_ON_FREE_LIST (rest, restbytes, index);
+      SETUP_ON_FREE_LIST (ADVANCE (vector, nbytes), restbytes, index);
     }
   return vector;
- }
+}
 
 /* Nonzero if VECTOR pointer is valid pointer inside BLOCK.  */
 
@@ -2759,15 +2781,30 @@ allocate_vector_from_block (size_t nbytes)
   ((char *) (vector) <= (block)->data           \
    + VECTOR_BLOCK_BYTES - VBLOCK_BYTES_MIN)
 
-/* Number of bytes used by vector-block-allocated object.  This is the only
-   place where we actually use the `nbytes' field of the vector-header.
-   I.e. we could get rid of the `nbytes' field by computing it based on the
-   vector-type.  */
+/* Return the memory footprint of V in bytes.  */
 
-#define PSEUDOVECTOR_NBYTES(vector) \
-  (PSEUDOVECTOR_TYPEP (&vector->header, PVEC_FREE)      \
-   ? vector->header.size & PSEUDOVECTOR_SIZE_MASK       \
-   : vector->header.next.nbytes)
+static ptrdiff_t
+vector_nbytes (struct Lisp_Vector *v)
+{
+  ptrdiff_t size = v->header.size & ~ARRAY_MARK_FLAG;
+
+  if (size & PSEUDOVECTOR_FLAG)
+    {
+      if (PSEUDOVECTOR_TYPEP (&v->header, PVEC_BOOL_VECTOR))
+        size = (bool_header_size
+                + (((struct Lisp_Bool_Vector *) v)->size
+                   + BOOL_VECTOR_BITS_PER_CHAR - 1)
+                / BOOL_VECTOR_BITS_PER_CHAR);
+      else
+        size = (header_size
+                + ((size & PSEUDOVECTOR_SIZE_MASK)
+                   + ((size & PSEUDOVECTOR_REST_MASK)
+                      >> PSEUDOVECTOR_SIZE_BITS)) * word_size);
+    }
+  else
+    size = header_size + size * word_size;
+  return vroundup (size);
+}
 
 /* Reclaim space used by unmarked vectors.  */
 
@@ -2775,7 +2812,8 @@ static void
 sweep_vectors (void)
 {
   struct vector_block *block = vector_blocks, **bprev = &vector_blocks;
-  struct Lisp_Vector *vector, *next, **vprev = &large_vectors;
+  struct large_vector *lv, **lvprev = &large_vectors;
+  struct Lisp_Vector *vector, *next;
 
   total_vectors = total_vector_slots = total_free_vector_slots = 0;
   memset (vector_free_lists, 0, sizeof (vector_free_lists));
@@ -2785,6 +2823,7 @@ sweep_vectors (void)
   for (block = vector_blocks; block; block = *bprev)
     {
       bool free_this_block = 0;
+      ptrdiff_t nbytes;
 
       for (vector = (struct Lisp_Vector *) block->data;
            VECTOR_IN_BLOCK (vector, block); vector = next)
@@ -2793,14 +2832,16 @@ sweep_vectors (void)
             {
               VECTOR_UNMARK (vector);
               total_vectors++;
-              total_vector_slots += vector->header.next.nbytes / word_size;
-              next = ADVANCE (vector, vector->header.next.nbytes);
+              nbytes = vector_nbytes (vector);
+              total_vector_slots += nbytes / word_size;
+              next = ADVANCE (vector, nbytes);
             }
           else
             {
-              ptrdiff_t nbytes = PSEUDOVECTOR_NBYTES (vector);
-              ptrdiff_t total_bytes = nbytes;
+              ptrdiff_t total_bytes;
 
+              nbytes = vector_nbytes (vector);
+              total_bytes = nbytes;
               next = ADVANCE (vector, nbytes);
 
               /* While NEXT is not marked, try to coalesce with VECTOR,
@@ -2810,7 +2851,7 @@ sweep_vectors (void)
                 {
                   if (VECTOR_MARKED_P (next))
                     break;
-                  nbytes = PSEUDOVECTOR_NBYTES (next);
+                  nbytes = vector_nbytes (next);
                   total_bytes += nbytes;
                   next = ADVANCE (next, nbytes);
                 }
@@ -2844,8 +2885,9 @@ sweep_vectors (void)
 
   /* Sweep large vectors.  */
 
-  for (vector = large_vectors; vector; vector = *vprev)
+  for (lv = large_vectors; lv; lv = *lvprev)
     {
+      vector = &lv->v;
       if (VECTOR_MARKED_P (vector))
         {
           VECTOR_UNMARK (vector);
@@ -2867,12 +2909,12 @@ sweep_vectors (void)
           else
             total_vector_slots
               += header_size / word_size + vector->header.size;
-          vprev = &vector->header.next.vector;
+          lvprev = &lv->next.vector;
         }
       else
         {
-          *vprev = vector->header.next.vector;
-          lisp_free (vector);
+          *lvprev = lv->next.vector;
+          lisp_free (lv);
         }
     }
 }
@@ -2904,9 +2946,12 @@ allocate_vectorlike (ptrdiff_t len)
         p = allocate_vector_from_block (vroundup (nbytes));
       else
         {
-          p = lisp_malloc (nbytes, MEM_TYPE_VECTORLIKE);
-          p->header.next.vector = large_vectors;
-          large_vectors = p;
+          struct large_vector *lv
+            = lisp_malloc (sizeof (*lv) + (len - 1) * word_size,
+                           MEM_TYPE_VECTORLIKE);
+          lv->next.vector = large_vectors;
+          large_vectors = lv;
+          p = &lv->v;
         }
 
 #ifdef DOUG_LEA_MALLOC
@@ -2943,16 +2988,21 @@ allocate_vector (EMACS_INT len)
 /* Allocate other vector-like structures.  */
 
 struct Lisp_Vector *
-allocate_pseudovector (int memlen, int lisplen, int tag)
+allocate_pseudovector (int memlen, int lisplen, enum pvec_type tag)
 {
   struct Lisp_Vector *v = allocate_vectorlike (memlen);
   int i;
 
+  /* Catch bogus values.  */
+  eassert (tag <= PVEC_FONT);
+  eassert (memlen - lisplen <= (1 << PSEUDOVECTOR_REST_BITS) - 1);
+  eassert (lisplen <= (1 << PSEUDOVECTOR_SIZE_BITS) - 1);
+
   /* Only the first lisplen slots will be traced normally by the GC.  */
   for (i = 0; i < lisplen; ++i)
     v->contents[i] = Qnil;
 
-  XSETPVECTYPESIZE (v, tag, lisplen);
+  XSETPVECTYPESIZE (v, tag, lisplen, memlen - lisplen);
   return v;
 }
 
@@ -2961,10 +3011,9 @@ allocate_buffer (void)
 {
   struct buffer *b = lisp_malloc (sizeof *b, MEM_TYPE_BUFFER);
 
-  XSETPVECTYPESIZE (b, PVEC_BUFFER, (offsetof (struct buffer, own_text)
-                                     - header_size) / word_size);
+  BUFFER_PVEC_INIT (b);
   /* Put B on the chain of all buffers including killed ones.  */
-  b->header.next.buffer = all_buffers;
+  b->next = all_buffers;
   all_buffers = b;
   /* Note that the rest fields of B are not initialized.  */
   return b;
@@ -4068,16 +4117,15 @@ live_vector_p (struct mem_node *m, void *p)
       while (VECTOR_IN_BLOCK (vector, block)
              && vector <= (struct Lisp_Vector *) p)
         {
-          if (PSEUDOVECTOR_TYPEP (&vector->header, PVEC_FREE))
-            vector = ADVANCE (vector, (vector->header.size
-                                       & PSEUDOVECTOR_SIZE_MASK));
-          else if (vector == p)
+          if (!PSEUDOVECTOR_TYPEP (&vector->header, PVEC_FREE) && vector == p)
             return 1;
           else
-            vector = ADVANCE (vector, vector->header.next.nbytes);
+            vector = ADVANCE (vector, vector_nbytes (vector));
         }
     }
-  else if (m->type == MEM_TYPE_VECTORLIKE && p == m->start)
+  else if (m->type == MEM_TYPE_VECTORLIKE
+           && (char *) p == ((char *) m->start
+                             + offsetof (struct large_vector, v)))
     /* This memory node corresponds to a large vector.  */
     return 1;
   return 0;
@@ -5687,7 +5735,7 @@ mark_object (Lisp_Object arg)
 
         if (ptr->header.size & PSEUDOVECTOR_FLAG)
           pvectype = ((ptr->header.size & PVEC_TYPE_MASK)
-                      >> PSEUDOVECTOR_SIZE_BITS);
+                      >> PSEUDOVECTOR_AREA_BITS);
         else
           pvectype = PVEC_NORMAL_VECTOR;
 
@@ -5766,6 +5814,9 @@ mark_object (Lisp_Object arg)
               struct Lisp_Hash_Table *h = (struct Lisp_Hash_Table *) ptr;
 
               mark_vectorlike (ptr);
+              mark_object (h->test.name);
+              mark_object (h->test.user_hash_function);
+              mark_object (h->test.user_cmp_function);
               /* If hash table is not weak, mark all keys and values.
                  For weak tables, mark only the vector.  */
               if (NILP (h->weak))
@@ -6317,7 +6368,7 @@ gc_sweep (void)
     for (buffer = all_buffers; buffer; buffer = *bprev)
       if (!VECTOR_MARKED_P (buffer))
         {
-          *bprev = buffer->header.next.buffer;
+          *bprev = buffer->next;
           lisp_free (buffer);
         }
       else
@@ -6326,7 +6377,7 @@ gc_sweep (void)
           /* Do not use buffer_(set|get)_intervals here.  */
           buffer->text->intervals = balance_intervals (buffer->text->intervals);
           total_buffers++;
-          bprev = &buffer->header.next.buffer;
+          bprev = &buffer->next;
         }
   }
 
diff --git a/src/buffer.c b/src/buffer.c
index bb69675346a..619a729a859 100644
--- a/src/buffer.c
+++ b/src/buffer.c
@@ -3132,8 +3132,8 @@ compare_overlays (const void *v1, const void *v2)
      between "equal" overlays.  The result can still change between
      invocations of Emacs, but it won't change in the middle of
      `find_field' (bug#6830).  */
-  if (XHASH (s1->overlay) != XHASH (s2->overlay))
-    return XHASH (s1->overlay) < XHASH (s2->overlay) ? -1 : 1;
+  if (!EQ (s1->overlay, s2->overlay))
+    return XLI (s1->overlay) < XLI (s2->overlay) ? -1 : 1;
   return 0;
 }
 
@@ -5105,11 +5105,6 @@ void
 init_buffer_once (void)
 {
   int idx;
-  /* If you add, remove, or reorder Lisp_Objects in a struct buffer, make
-     sure that this is still correct.  Otherwise, mark_vectorlike may not
-     trace all Lisp_Objects in buffer_defaults and buffer_local_symbols.  */
-  const int pvecsize
-    = (offsetof (struct buffer, own_text) - header_size) / word_size;
 
   memset (buffer_permanent_local_flags, 0, sizeof buffer_permanent_local_flags);
 
@@ -5132,8 +5127,8 @@ init_buffer_once (void)
   /* This is not strictly necessary, but let's make them initialized.  */
   bset_name (&buffer_defaults, build_pure_c_string (" *buffer-defaults*"));
   bset_name (&buffer_local_symbols, build_pure_c_string (" *buffer-local-symbols*"));
-  XSETPVECTYPESIZE (&buffer_defaults, PVEC_BUFFER, pvecsize);
-  XSETPVECTYPESIZE (&buffer_local_symbols, PVEC_BUFFER, pvecsize);
+  BUFFER_PVEC_INIT (&buffer_defaults);
+  BUFFER_PVEC_INIT (&buffer_local_symbols);
 
   /* Set up the default values of various buffer slots.  */
   /* Must do these before making the first buffer! */
diff --git a/src/buffer.h b/src/buffer.h
index 9e0e9eef0b1..fbbbf1b8434 100644
--- a/src/buffer.h
+++ b/src/buffer.h
@@ -482,11 +482,6 @@ struct buffer_text
 
 struct buffer
 {
-  /* HEADER.NEXT is the next buffer, in chain of all buffers, including killed
-     buffers.  This chain, starting from all_buffers, is used only for garbage
-     collection, in order to collect killed buffers properly.  Note that large
-     vectors and large pseudo-vector objects are all on another chain starting
-     from large_vectors.  */
   struct vectorlike_header header;
 
   /* The name of this buffer.  */
@@ -750,6 +745,9 @@ struct buffer
      In an indirect buffer, this is the own_text field of another buffer.  */
   struct buffer_text *text;
 
+  /* Next buffer, in chain of all buffers, including killed ones.  */
+  struct buffer *next;
+
   /* Char position of point in buffer.  */
   ptrdiff_t pt;
 
@@ -959,6 +957,27 @@ bset_width_table (struct buffer *b, Lisp_Object val)
   b->INTERNAL_FIELD (width_table) = val;
 }
 
+/* Number of Lisp_Objects at the beginning of struct buffer.
+   If you add, remove, or reorder Lisp_Objects within buffer
+   structure, make sure that this is still correct.  */
+
+#define BUFFER_LISP_SIZE                                                \
+  ((offsetof (struct buffer, own_text) - header_size) / word_size)
+
+/* Size of the struct buffer part beyond leading Lisp_Objects, in word_size
+   units.  Rounding is needed for --with-wide-int configuration.  */
+
+#define BUFFER_REST_SIZE                                                \
+  ((((sizeof (struct buffer) - offsetof (struct buffer, own_text))      \
+     + (word_size - 1)) & ~(word_size - 1)) / word_size)
+
+/* Initialize the pseudovector header of buffer object.  BUFFER_LISP_SIZE
+   is required for GC, but BUFFER_REST_SIZE is set up just to be consistent
+   with other pseudovectors.  */
+
+#define BUFFER_PVEC_INIT(b)                                    \
+  XSETPVECTYPESIZE (b, PVEC_BUFFER, BUFFER_LISP_SIZE, BUFFER_REST_SIZE)
+
 /* Convenient check whether buffer B is live.  */
 
 #define BUFFER_LIVE_P(b) (!NILP (BVAR (b, name)))
@@ -986,7 +1005,7 @@ extern struct buffer *all_buffers;
 /* Used to iterate over the chain above.  */
 
 #define FOR_EACH_BUFFER(b) \
-  for ((b) = all_buffers; (b); (b) = (b)->header.next.buffer)
+  for ((b) = all_buffers; (b); (b) = (b)->next)
 
 /* This points to the current buffer.  */
 
diff --git a/src/category.c b/src/category.c
index fe02303f679..31cc90bca68 100644
--- a/src/category.c
+++ b/src/category.c
@@ -78,10 +78,10 @@ hash_get_category_set (Lisp_Object table, Lisp_Object category_set)
   if (NILP (XCHAR_TABLE (table)->extras[1]))
     set_char_table_extras
       (table, 1,
-       make_hash_table (Qequal, make_number (DEFAULT_HASH_SIZE),
+       make_hash_table (hashtest_equal, make_number (DEFAULT_HASH_SIZE),
                         make_float (DEFAULT_REHASH_SIZE),
                         make_float (DEFAULT_REHASH_THRESHOLD),
-                        Qnil, Qnil, Qnil));
+                        Qnil));
   h = XHASH_TABLE (XCHAR_TABLE (table)->extras[1]);
   i = hash_lookup (h, category_set, &hash);
   if (i >= 0)
diff --git a/src/composite.c b/src/composite.c
index 6c603fab3fc..bcde0a4c9e6 100644
--- a/src/composite.c
+++ b/src/composite.c
@@ -676,7 +676,7 @@ composition_gstring_put_cache (Lisp_Object gstring, ptrdiff_t len)
   ptrdiff_t i;
 
   header = LGSTRING_HEADER (gstring);
-  hash = h->hashfn (h, header);
+  hash = h->test.hashfn (&h->test, header);
   if (len < 0)
     {
       ptrdiff_t j, glyph_len = LGSTRING_GLYPH_LEN (gstring);
@@ -1382,7 +1382,7 @@ composition_update_it (struct composition_it *cmp_it, ptrdiff_t charpos, ptrdiff
     }
   else
     {
-      /* automatic composition */
+      /* Automatic composition.  */
       Lisp_Object gstring = composition_gstring_from_id (cmp_it->id);
       Lisp_Object glyph;
       ptrdiff_t from;
diff --git a/src/data.c b/src/data.c
index abcdd4dca0d..09899400b68 100644
--- a/src/data.c
+++ b/src/data.c
@@ -81,6 +81,7 @@ Lisp_Object Qfont_spec, Qfont_entity, Qfont_object;
 static Lisp_Object Qdefun;
 
 Lisp_Object Qinteractive_form;
+static Lisp_Object Qdefalias_fset_function;
 
 static void swap_in_symval_forwarding (struct Lisp_Symbol *, struct Lisp_Buffer_Local_Value *);
 
@@ -444,7 +445,7 @@ DEFUN ("floatp", Ffloatp, Sfloatp, 1, 1, 0,
 }
 
 
-/* Extract and set components of lists */
+/* Extract and set components of lists.  */
 
 DEFUN ("car", Fcar, Scar, 1, 1, 0,
        doc: /* Return the car of LIST.  If arg is nil, return nil.
@@ -608,27 +609,18 @@ DEFUN ("fset", Ffset, Sfset, 2, 2, 0,
   (register Lisp_Object symbol, Lisp_Object definition)
 {
   register Lisp_Object function;
-
   CHECK_SYMBOL (symbol);
-  if (NILP (symbol) || EQ (symbol, Qt))
-    xsignal1 (Qsetting_constant, symbol);
 
   function = XSYMBOL (symbol)->function;
 
   if (!NILP (Vautoload_queue) && !EQ (function, Qunbound))
     Vautoload_queue = Fcons (Fcons (symbol, function), Vautoload_queue);
 
-  if (CONSP (function) && EQ (XCAR (function), Qautoload))
+  if (AUTOLOADP (function))
     Fput (symbol, Qautoload, XCDR (function));
 
   set_symbol_function (symbol, definition);
-  /* Handle automatic advice activation.  */
-  if (CONSP (XSYMBOL (symbol)->plist)
-      && !NILP (Fget (symbol, Qad_advice_info)))
-    {
-      call2 (Qad_activate_internal, symbol, Qnil);
-      definition = XSYMBOL (symbol)->function;
-    }
+
   return definition;
 }
 
@@ -642,15 +634,32 @@ The return value is undefined.  */)
   (register Lisp_Object symbol, Lisp_Object definition, Lisp_Object docstring)
 {
   CHECK_SYMBOL (symbol);
-  if (CONSP (XSYMBOL (symbol)->function)
-      && EQ (XCAR (XSYMBOL (symbol)->function), Qautoload))
-    LOADHIST_ATTACH (Fcons (Qt, symbol));
   if (!NILP (Vpurify_flag)
       /* If `definition' is a keymap, immutable (and copying) is wrong.  */
       && !KEYMAPP (definition))
     definition = Fpurecopy (definition);
-  definition = Ffset (symbol, definition);
-  LOADHIST_ATTACH (Fcons (Qdefun, symbol));
+
+  {
+    bool autoload = AUTOLOADP (definition);
+    if (NILP (Vpurify_flag) || !autoload)
+      { /* Only add autoload entries after dumping, because the ones before are
+           not useful and else we get loads of them from the loaddefs.el.  */
+
+        if (AUTOLOADP (XSYMBOL (symbol)->function))
+          /* Remember that the function was already an autoload.  */
+          LOADHIST_ATTACH (Fcons (Qt, symbol));
+        LOADHIST_ATTACH (Fcons (autoload ? Qautoload : Qdefun, symbol));
+      }
+  }
+
+  { /* Handle automatic advice activation.  */
+    Lisp_Object hook = Fget (symbol, Qdefalias_fset_function);
+    if (!NILP (hook))
+      call2 (hook, symbol, definition);
+    else
+      Ffset (symbol, definition);
+  }
+
   if (!NILP (docstring))
     Fput (symbol, Qfunction_documentation, docstring);
   /* We used to return `definition', but now that `defun' and `defmacro' expand
@@ -680,12 +689,10 @@ function with `&rest' args, or `unevalled' for a special form.  */)
   CHECK_SUBR (subr);
   minargs = XSUBR (subr)->min_args;
   maxargs = XSUBR (subr)->max_args;
-  if (maxargs == MANY)
-    return Fcons (make_number (minargs), Qmany);
-  else if (maxargs == UNEVALLED)
-    return Fcons (make_number (minargs), Qunevalled);
-  else
-    return Fcons (make_number (minargs), make_number (maxargs));
+  return Fcons (make_number (minargs),
+                maxargs == MANY ?        Qmany
+                : maxargs == UNEVALLED ? Qunevalled
+                :                        make_number (maxargs));
 }
 
 DEFUN ("subr-name", Fsubr_name, Ssubr_name, 1, 1, 0,
@@ -711,7 +718,7 @@ Value, if non-nil, is a list \(interactive SPEC).  */)
     return Qnil;
 
   /* Use an `interactive-form' property if present, analogous to the
-     function-documentation property. */
+     function-documentation property.  */
   fun = cmd;
   while (SYMBOLP (fun))
     {
@@ -735,6 +742,8 @@ Value, if non-nil, is a list \(interactive SPEC).  */)
       if ((ASIZE (fun) & PSEUDOVECTOR_SIZE_MASK) > COMPILED_INTERACTIVE)
         return list2 (Qinteractive, AREF (fun, COMPILED_INTERACTIVE));
     }
+  else if (AUTOLOADP (fun))
+    return Finteractive_form (Fautoload_do_load (fun, cmd, Qnil));
   else if (CONSP (fun))
     {
       Lisp_Object funcar = XCAR (fun);
@@ -742,14 +751,6 @@ Value, if non-nil, is a list \(interactive SPEC).  */)
         return Fassq (Qinteractive, Fcdr (Fcdr (XCDR (fun))));
       else if (EQ (funcar, Qlambda))
         return Fassq (Qinteractive, Fcdr (XCDR (fun)));
-      else if (EQ (funcar, Qautoload))
-        {
-          struct gcpro gcpro1;
-          GCPRO1 (cmd);
-          Fautoload_do_load (fun, cmd, Qnil);
-          UNGCPRO;
-          return Finteractive_form (cmd);
-        }
     }
   return Qnil;
 }
@@ -2695,10 +2696,10 @@ usage: (* &rest NUMBERS-OR-MARKERS)  */)
   return arith_driver (Amult, nargs, args);
 }
 
-DEFUN ("/", Fquo, Squo, 2, MANY, 0,
+DEFUN ("/", Fquo, Squo, 1, MANY, 0,
        doc: /* Return first argument divided by all the remaining arguments.
 The arguments must be numbers or markers.
-usage: (/ DIVIDEND DIVISOR &rest DIVISORS)  */)
+usage: (/ DIVIDEND &rest DIVISORS)  */)
   (ptrdiff_t nargs, Lisp_Object *args)
 {
   ptrdiff_t argnum;
@@ -3063,6 +3064,7 @@ syms_of_data (void)
   DEFSYM (Qfont_object, "font-object");
 
   DEFSYM (Qinteractive_form, "interactive-form");
+  DEFSYM (Qdefalias_fset_function, "defalias-fset-function");
 
   defsubr (&Sindirect_variable);
   defsubr (&Sinteractive_form);
diff --git a/src/doc.c b/src/doc.c
index 9ead1addfba..1d3d1e64442 100644
--- a/src/doc.c
+++ b/src/doc.c
@@ -21,7 +21,7 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 #include <config.h>
 
 #include <sys/types.h>
-#include <sys/file.h>   /* Must be after sys/types.h for USG*/
+#include <sys/file.h>   /* Must be after sys/types.h for USG.  */
 #include <fcntl.h>
 #include <unistd.h>
 
@@ -42,7 +42,7 @@ static ptrdiff_t get_doc_string_buffer_size;
 
 static unsigned char *read_bytecode_pointer;
 
-/* readchar in lread.c calls back here to fetch the next byte.
+/* `readchar' in lread.c calls back here to fetch the next byte.
    If UNREADFLAG is 1, we unread a byte.  */
 
 int
@@ -338,15 +338,9 @@ string is passed through `substitute-command-keys'.  */)
 
   doc = Qnil;
 
-  if (SYMBOLP (function))
-    {
-      Lisp_Object tem = Fget (function, Qfunction_documentation);
-      if (!NILP (tem))
-        return Fdocumentation_property (function, Qfunction_documentation,
-                                        raw);
-    }
-
   fun = Findirect_function (function, Qnil);
+  if (CONSP (fun) && EQ (XCAR (fun), Qmacro))
+    fun = XCDR (fun);
   if (SUBRP (fun))
     {
       if (XSUBR (fun)->doc == 0)
@@ -400,8 +394,6 @@ string is passed through `substitute-command-keys'.  */)
           else
             return Qnil;
         }
-      else if (EQ (funcar, Qmacro))
-        return Fdocumentation (Fcdr (fun), raw);
       else
         goto oops;
     }
@@ -411,16 +403,19 @@ string is passed through `substitute-command-keys'.  */)
       xsignal1 (Qinvalid_function, fun);
     }
 
-  /* Check for an advised function.  Its doc string
-     has an `ad-advice-info' text property.  */
+  /* Check for a dynamic docstring.  These come with
+     a dynamic-docstring-function text property.  */
   if (STRINGP (doc))
     {
-      Lisp_Object innerfunc;
-      innerfunc = Fget_text_property (make_number (0),
-                                      intern ("ad-advice-info"),
+      Lisp_Object func
+        = Fget_text_property (make_number (0),
+                              intern ("dynamic-docstring-function"),
                                       doc);
-      if (! NILP (innerfunc))
-        doc = call1 (intern ("ad-make-advised-docstring"), innerfunc);
+      if (!NILP (func))
+        /* Pass both `doc' and `function' since `function' can be needed, and
+           finding `doc' can be annoying: calling `documentation' is not an
+           option because it would infloop.  */
+        doc = call2 (func, doc, function);
     }
 
   /* If DOC is 0, it's typically because of a dumped file missing
@@ -528,6 +523,8 @@ store_function_docstring (Lisp_Object obj, ptrdiff_t offset)
         {
           tem = Fcdr (Fcdr (fun));
           if (CONSP (tem) && INTEGERP (XCAR (tem)))
+            /* FIXME: This modifies typically pure hash-cons'd data, so its
+               correctness is quite delicate.  */
             XSETCAR (tem, make_number (offset));
         }
       else if (EQ (tem, Qmacro))
diff --git a/src/emacs.c b/src/emacs.c
index 894e4d3cb30..aece6069230 100644
--- a/src/emacs.c
+++ b/src/emacs.c
@@ -1157,6 +1157,7 @@ Using an Emacs configured with --with-x-toolkit=lucid does not have this problem
 
       /* Called before syms_of_fileio, because it sets up Qerror_condition.  */
       syms_of_data ();
+      syms_of_fns ();      /* Before syms_of_charset which uses hashtables.  */
       syms_of_fileio ();
       /* Before syms_of_coding to initialize Vgc_cons_threshold.  */
       syms_of_alloc ();
@@ -1168,7 +1169,7 @@ Using an Emacs configured with --with-x-toolkit=lucid does not have this problem
 
       init_window_once ();      /* Init the window system.  */
 #ifdef HAVE_WINDOW_SYSTEM
-      init_fringe_once ();      /* Swap bitmaps if necessary. */
+      init_fringe_once ();      /* Swap bitmaps if necessary.  */
 #endif /* HAVE_WINDOW_SYSTEM */
     }
 
@@ -1351,7 +1352,6 @@ Using an Emacs configured with --with-x-toolkit=lucid does not have this problem
       syms_of_lread ();
       syms_of_print ();
       syms_of_eval ();
-      syms_of_fns ();
       syms_of_floatfns ();
 
       syms_of_buffer ();
diff --git a/src/eval.c b/src/eval.c
index 975204da017..dcd48cb7250 100644
--- a/src/eval.c
+++ b/src/eval.c
@@ -1876,26 +1876,19 @@ this does nothing and returns nil.  */)
   CHECK_STRING (file);
 
   /* If function is defined and not as an autoload, don't override.  */
-  if ((CONSP (XSYMBOL (function)->function)
-       && EQ (XCAR (XSYMBOL (function)->function), Qautoload)))
-    /* Remember that the function was already an autoload.  */
-    LOADHIST_ATTACH (Fcons (Qt, function));
-  else if (!EQ (XSYMBOL (function)->function, Qunbound))
+  if (!EQ (XSYMBOL (function)->function, Qunbound)
+      && !AUTOLOADP (XSYMBOL (function)->function))
     return Qnil;
 
-  if (NILP (Vpurify_flag))
-    /* Only add entries after dumping, because the ones before are
-       not useful and else we get loads of them from the loaddefs.el.  */
-    LOADHIST_ATTACH (Fcons (Qautoload, function));
-  else if (EQ (docstring, make_number (0)))
+  if (!NILP (Vpurify_flag) && EQ (docstring, make_number (0)))
     /* `read1' in lread.c has found the docstring starting with "\
        and assumed the docstring will be provided by Snarf-documentation, so it
        passed us 0 instead.  But that leads to accidental sharing in purecopy's
        hash-consing, so we use a (hopefully) unique integer instead.  */
-    docstring = make_number (XUNTAG (function, Lisp_Symbol));
-  return Ffset (function,
-                Fpurecopy (list5 (Qautoload, file, docstring,
-                                  interactive, type)));
+    docstring = make_number (XHASH (function));
+  return Fdefalias (function,
+                    list5 (Qautoload, file, docstring, interactive, type),
+                    Qnil);
 }
 
 Lisp_Object
diff --git a/src/fileio.c b/src/fileio.c
index d47d7dd9e0b..b9541e78838 100644
--- a/src/fileio.c
+++ b/src/fileio.c
@@ -5076,7 +5076,7 @@ See Info node `(elisp)Modification Time' for more details.  */)
   struct stat st;
   Lisp_Object handler;
   Lisp_Object filename;
-  EMACS_TIME mtime, diff;
+  EMACS_TIME mtime;
 
   if (NILP (buf))
     b = current_buffer;
@@ -5101,13 +5101,7 @@ See Info node `(elisp)Modification Time' for more details.  */)
   mtime = (stat (SSDATA (filename), &st) == 0
            ? get_stat_mtime (&st)
            : time_error_value (errno));
-  if ((EMACS_TIME_EQ (mtime, b->modtime)
-       /* If both exist, accept them if they are off by one second.  */
-       || (EMACS_TIME_VALID_P (mtime) && EMACS_TIME_VALID_P (b->modtime)
-           && ((diff = (EMACS_TIME_LT (mtime, b->modtime)
-                        ? sub_emacs_time (b->modtime, mtime)
-                        : sub_emacs_time (mtime, b->modtime))),
-               EMACS_TIME_LE (diff, make_emacs_time (1, 0)))))
+  if (EMACS_TIME_EQ (mtime, b->modtime)
       && (st.st_size == b->modtime_size
           || b->modtime_size < 0))
     return Qt;
diff --git a/src/fns.c b/src/fns.c
index b1ba5ce9509..7c2222e9805 100644
--- a/src/fns.c
+++ b/src/fns.c
@@ -2014,7 +2014,7 @@ internal_equal (Lisp_Object o1, Lisp_Object o2, int depth, bool props)
         d1 = extract_float (o1);
         d2 = extract_float (o2);
         /* If d is a NaN, then d != d. Two NaNs should be `equal' even
-           though they are not =. */
+           though they are not =.  */
         return d1 == d2 || (d1 != d1 && d2 != d2);
       }
 
@@ -2076,9 +2076,8 @@ internal_equal (Lisp_Object o1, Lisp_Object o2, int depth, bool props)
            are sensible to compare, so eliminate the others now.  */
         if (size & PSEUDOVECTOR_FLAG)
           {
-            if (!(size & ((PVEC_COMPILED | PVEC_CHAR_TABLE
-                           | PVEC_SUB_CHAR_TABLE | PVEC_FONT)
-                          << PSEUDOVECTOR_SIZE_BITS)))
+            if (((size & PVEC_TYPE_MASK) >> PSEUDOVECTOR_AREA_BITS)
+                < PVEC_COMPILED)
               return 0;
             size &= PSEUDOVECTOR_SIZE_MASK;
           }
@@ -3332,8 +3331,8 @@ static struct Lisp_Hash_Table *weak_hash_tables;
 
 /* Various symbols.  */
 
-static Lisp_Object Qhash_table_p, Qkey, Qvalue;
-Lisp_Object Qeq, Qeql, Qequal;
+static Lisp_Object Qhash_table_p, Qkey, Qvalue, Qeql;
+Lisp_Object Qeq, Qequal;
 Lisp_Object QCtest, QCsize, QCrehash_size, QCrehash_threshold, QCweakness;
 static Lisp_Object Qhash_table_test, Qkey_or_value, Qkey_and_value;
 
@@ -3425,14 +3424,17 @@ larger_vector (Lisp_Object vec, ptrdiff_t incr_min, ptrdiff_t nitems_max)
                          Low-level Functions
  ***********************************************************************/
 
+static struct hash_table_test hashtest_eq;
+struct hash_table_test hashtest_eql, hashtest_equal;
+
 /* Compare KEY1 which has hash code HASH1 and KEY2 with hash code
    HASH2 in hash table H using `eql'.  Value is true if KEY1 and
    KEY2 are the same.  */
 
 static bool
-cmpfn_eql (struct Lisp_Hash_Table *h,
-           Lisp_Object key1, EMACS_UINT hash1,
-           Lisp_Object key2, EMACS_UINT hash2)
+cmpfn_eql (struct hash_table_test *ht,
+           Lisp_Object key1,
+           Lisp_Object key2)
 {
   return (FLOATP (key1)
           && FLOATP (key2)
@@ -3445,11 +3447,11 @@ cmpfn_eql (struct Lisp_Hash_Table *h,
    KEY2 are the same.  */
 
 static bool
-cmpfn_equal (struct Lisp_Hash_Table *h,
-             Lisp_Object key1, EMACS_UINT hash1,
-             Lisp_Object key2, EMACS_UINT hash2)
+cmpfn_equal (struct hash_table_test *ht,
+             Lisp_Object key1,
+             Lisp_Object key2)
 {
-  return hash1 == hash2 && !NILP (Fequal (key1, key2));
+  return !NILP (Fequal (key1, key2));
 }
 
 
@@ -3458,21 +3460,16 @@ cmpfn_equal (struct Lisp_Hash_Table *h,
    if KEY1 and KEY2 are the same.  */
 
 static bool
-cmpfn_user_defined (struct Lisp_Hash_Table *h,
-                    Lisp_Object key1, EMACS_UINT hash1,
-                    Lisp_Object key2, EMACS_UINT hash2)
+cmpfn_user_defined (struct hash_table_test *ht,
+                    Lisp_Object key1,
+                    Lisp_Object key2)
 {
-  if (hash1 == hash2)
-    {
-      Lisp_Object args[3];
+  Lisp_Object args[3];
 
-      args[0] = h->user_cmp_function;
-      args[1] = key1;
-      args[2] = key2;
-      return !NILP (Ffuncall (3, args));
-    }
-  else
-    return 0;
+  args[0] = ht->user_cmp_function;
+  args[1] = key1;
+  args[2] = key2;
+  return !NILP (Ffuncall (3, args));
 }
 
 
@@ -3481,54 +3478,48 @@ cmpfn_user_defined (struct Lisp_Hash_Table *h,
    in a Lisp integer.  */
 
 static EMACS_UINT
-hashfn_eq (struct Lisp_Hash_Table *h, Lisp_Object key)
+hashfn_eq (struct hash_table_test *ht, Lisp_Object key)
 {
-  EMACS_UINT hash = XUINT (key) ^ XTYPE (key);
-  eassert ((hash & ~INTMASK) == 0);
+  EMACS_UINT hash = XHASH (key) ^ XTYPE (key);
   return hash;
 }
 
-
 /* Value is a hash code for KEY for use in hash table H which uses
    `eql' to compare keys.  The hash code returned is guaranteed to fit
    in a Lisp integer.  */
 
 static EMACS_UINT
-hashfn_eql (struct Lisp_Hash_Table *h, Lisp_Object key)
+hashfn_eql (struct hash_table_test *ht, Lisp_Object key)
 {
   EMACS_UINT hash;
   if (FLOATP (key))
     hash = sxhash (key, 0);
   else
-    hash = XUINT (key) ^ XTYPE (key);
-  eassert ((hash & ~INTMASK) == 0);
+    hash = XHASH (key) ^ XTYPE (key);
   return hash;
 }
 
-
 /* Value is a hash code for KEY for use in hash table H which uses
    `equal' to compare keys.  The hash code returned is guaranteed to fit
    in a Lisp integer.  */
 
 static EMACS_UINT
-hashfn_equal (struct Lisp_Hash_Table *h, Lisp_Object key)
+hashfn_equal (struct hash_table_test *ht, Lisp_Object key)
 {
   EMACS_UINT hash = sxhash (key, 0);
-  eassert ((hash & ~INTMASK) == 0);
   return hash;
 }
 
-
 /* Value is a hash code for KEY for use in hash table H which uses as
    user-defined function to compare keys.  The hash code returned is
    guaranteed to fit in a Lisp integer.  */
 
 static EMACS_UINT
-hashfn_user_defined (struct Lisp_Hash_Table *h, Lisp_Object key)
+hashfn_user_defined (struct hash_table_test *ht, Lisp_Object key)
 {
   Lisp_Object args[2], hash;
 
-  args[0] = h->user_hash_function;
+  args[0] = ht->user_hash_function;
   args[1] = key;
   hash = Ffuncall (2, args);
   if (!INTEGERP (hash))
@@ -3564,9 +3555,9 @@ hashfn_user_defined (struct Lisp_Hash_Table *h, Lisp_Object key)
    one of the symbols `key', `value', `key-or-value', or `key-and-value'.  */
 
 Lisp_Object
-make_hash_table (Lisp_Object test, Lisp_Object size, Lisp_Object rehash_size,
-                 Lisp_Object rehash_threshold, Lisp_Object weak,
-                 Lisp_Object user_test, Lisp_Object user_hash)
+make_hash_table (struct hash_table_test test,
+                 Lisp_Object size, Lisp_Object rehash_size,
+                 Lisp_Object rehash_threshold, Lisp_Object weak)
 {
   struct Lisp_Hash_Table *h;
   Lisp_Object table;
@@ -3575,7 +3566,7 @@ make_hash_table (Lisp_Object test, Lisp_Object size, Lisp_Object rehash_size,
   double index_float;
 
   /* Preconditions.  */
-  eassert (SYMBOLP (test));
+  eassert (SYMBOLP (test.name));
   eassert (INTEGERP (size) && XINT (size) >= 0);
   eassert ((INTEGERP (rehash_size) && XINT (rehash_size) > 0)
            || (FLOATP (rehash_size) && 1 < XFLOAT_DATA (rehash_size)));
@@ -3599,29 +3590,6 @@ make_hash_table (Lisp_Object test, Lisp_Object size, Lisp_Object rehash_size,
 
   /* Initialize hash table slots.  */
   h->test = test;
-  if (EQ (test, Qeql))
-    {
-      h->cmpfn = cmpfn_eql;
-      h->hashfn = hashfn_eql;
-    }
-  else if (EQ (test, Qeq))
-    {
-      h->cmpfn = NULL;
-      h->hashfn = hashfn_eq;
-    }
-  else if (EQ (test, Qequal))
-    {
-      h->cmpfn = cmpfn_equal;
-      h->hashfn = hashfn_equal;
-    }
-  else
-    {
-      h->user_cmp_function = user_test;
-      h->user_hash_function = user_hash;
-      h->cmpfn = cmpfn_user_defined;
-      h->hashfn = hashfn_user_defined;
-    }
-
   h->weak = weak;
   h->rehash_threshold = rehash_threshold;
   h->rehash_size = rehash_size;
@@ -3661,12 +3629,9 @@ copy_hash_table (struct Lisp_Hash_Table *h1)
 {
   Lisp_Object table;
   struct Lisp_Hash_Table *h2;
-  struct Lisp_Vector *next;
 
   h2 = allocate_hash_table ();
-  next = h2->header.next.vector;
   *h2 = *h1;
-  h2->header.next.vector = next;
   h2->key_and_value = Fcopy_sequence (h1->key_and_value);
   h2->hash = Fcopy_sequence (h1->hash);
   h2->next = Fcopy_sequence (h1->next);
@@ -3780,7 +3745,8 @@ hash_lookup (struct Lisp_Hash_Table *h, Lisp_Object key, EMACS_UINT *hash)
   ptrdiff_t start_of_bucket;
   Lisp_Object idx;
 
-  hash_code = h->hashfn (h, key);
+  hash_code = h->test.hashfn (&h->test, key);
+  eassert ((hash_code & ~INTMASK) == 0);
   if (hash)
     *hash = hash_code;
 
@@ -3792,9 +3758,9 @@ hash_lookup (struct Lisp_Hash_Table *h, Lisp_Object key, EMACS_UINT *hash)
     {
       ptrdiff_t i = XFASTINT (idx);
       if (EQ (key, HASH_KEY (h, i))
-          || (h->cmpfn
-              && h->cmpfn (h, key, hash_code,
-                           HASH_KEY (h, i), XUINT (HASH_HASH (h, i)))))
+          || (h->test.cmpfn
+              && hash_code == XUINT (HASH_HASH (h, i))
+              && h->test.cmpfn (&h->test, key, HASH_KEY (h, i))))
         break;
       idx = HASH_NEXT (h, i);
     }
@@ -3845,7 +3811,8 @@ hash_remove_from_table (struct Lisp_Hash_Table *h, Lisp_Object key)
   ptrdiff_t start_of_bucket;
   Lisp_Object idx, prev;
 
-  hash_code = h->hashfn (h, key);
+  hash_code = h->test.hashfn (&h->test, key);
+  eassert ((hash_code & ~INTMASK) == 0);
   start_of_bucket = hash_code % ASIZE (h->index);
   idx = HASH_INDEX (h, start_of_bucket);
   prev = Qnil;
@@ -3856,9 +3823,9 @@ hash_remove_from_table (struct Lisp_Hash_Table *h, Lisp_Object key)
       ptrdiff_t i = XFASTINT (idx);
 
       if (EQ (key, HASH_KEY (h, i))
-          || (h->cmpfn
-              && h->cmpfn (h, key, hash_code,
-                           HASH_KEY (h, i), XUINT (HASH_HASH (h, i)))))
+          || (h->test.cmpfn
+              && hash_code == XUINT (HASH_HASH (h, i))
+              && h->test.cmpfn (&h->test, key, HASH_KEY (h, i))))
         {
           /* Take entry out of collision chain.  */
           if (NILP (prev))
@@ -4070,13 +4037,6 @@ sweep_weak_hash_tables (void)
 
 #define SXHASH_MAX_LEN   7
 
-/* Combine two integers X and Y for hashing.  The result might not fit
-   into a Lisp integer.  */
-
-#define SXHASH_COMBINE(X, Y)                                            \
-  ((((EMACS_UINT) (X) << 4) + ((EMACS_UINT) (X) >> (BITS_PER_EMACS_INT - 4))) \
-   + (EMACS_UINT) (Y))
-
 /* Hash X, returning a value that fits into a Lisp integer.  */
 #define SXHASH_REDUCE(X) \
   ((((X) ^ (X) >> (BITS_PER_EMACS_INT - FIXNUM_BITS))) & INTMASK)
@@ -4095,7 +4055,7 @@ hash_string (char const *ptr, ptrdiff_t len)
   while (p != end)
     {
       c = *p++;
-      hash = SXHASH_COMBINE (hash, c);
+      hash = sxhash_combine (hash, c);
     }
 
   return hash;
@@ -4129,7 +4089,7 @@ sxhash_float (double val)
   u.val = val;
   memset (&u.val + 1, 0, sizeof u - sizeof u.val);
   for (i = 0; i < WORDS_PER_DOUBLE; i++)
-    hash = SXHASH_COMBINE (hash, u.word[i]);
+    hash = sxhash_combine (hash, u.word[i]);
   return SXHASH_REDUCE (hash);
 }
 
@@ -4148,13 +4108,13 @@ sxhash_list (Lisp_Object list, int depth)
          list = XCDR (list), ++i)
       {
         EMACS_UINT hash2 = sxhash (XCAR (list), depth + 1);
-        hash = SXHASH_COMBINE (hash, hash2);
+        hash = sxhash_combine (hash, hash2);
       }
 
   if (!NILP (list))
     {
       EMACS_UINT hash2 = sxhash (list, depth + 1);
-      hash = SXHASH_COMBINE (hash, hash2);
+      hash = sxhash_combine (hash, hash2);
     }
 
   return SXHASH_REDUCE (hash);
@@ -4174,7 +4134,7 @@ sxhash_vector (Lisp_Object vec, int depth)
   for (i = 0; i < n; ++i)
     {
       EMACS_UINT hash2 = sxhash (AREF (vec, i), depth + 1);
-      hash = SXHASH_COMBINE (hash, hash2);
+      hash = sxhash_combine (hash, hash2);
     }
 
   return SXHASH_REDUCE (hash);
@@ -4190,7 +4150,7 @@ sxhash_bool_vector (Lisp_Object vec)
 
   n = min (SXHASH_MAX_LEN, XBOOL_VECTOR (vec)->header.size);
   for (i = 0; i < n; ++i)
-    hash = SXHASH_COMBINE (hash, XBOOL_VECTOR (vec)->data[i]);
+    hash = sxhash_combine (hash, XBOOL_VECTOR (vec)->data[i]);
 
   return SXHASH_REDUCE (hash);
 }
@@ -4214,7 +4174,7 @@ sxhash (Lisp_Object obj, int depth)
       break;
 
     case Lisp_Misc:
-      hash = XUINT (obj);
+      hash = XHASH (obj);
       break;
 
     case Lisp_Symbol:
@@ -4238,7 +4198,7 @@ sxhash (Lisp_Object obj, int depth)
       else
         /* Others are `equal' if they are `eq', so let's take their
            address as hash.  */
-        hash = XUINT (obj);
+        hash = XHASH (obj);
       break;
 
     case Lisp_Cons:
@@ -4307,7 +4267,7 @@ usage: (make-hash-table &rest KEYWORD-ARGS)  */)
   (ptrdiff_t nargs, Lisp_Object *args)
 {
   Lisp_Object test, size, rehash_size, rehash_threshold, weak;
-  Lisp_Object user_test, user_hash;
+  struct hash_table_test testdesc;
   char *used;
   ptrdiff_t i;
 
@@ -4319,7 +4279,13 @@ usage: (make-hash-table &rest KEYWORD-ARGS)  */)
   /* See if there's a `:test TEST' among the arguments.  */
   i = get_key_arg (QCtest, nargs, args, used);
   test = i ? args[i] : Qeql;
-  if (!EQ (test, Qeq) && !EQ (test, Qeql) && !EQ (test, Qequal))
+  if (EQ (test, Qeq))
+    testdesc = hashtest_eq;
+  else if (EQ (test, Qeql))
+    testdesc = hashtest_eql;
+  else if (EQ (test, Qequal))
+    testdesc = hashtest_equal;
+  else
     {
       /* See if it is a user-defined test.  */
       Lisp_Object prop;
@@ -4327,11 +4293,12 @@ usage: (make-hash-table &rest KEYWORD-ARGS)  */)
       prop = Fget (test, Qhash_table_test);
       if (!CONSP (prop) || !CONSP (XCDR (prop)))
         signal_error ("Invalid hash table test", test);
-      user_test = XCAR (prop);
-      user_hash = XCAR (XCDR (prop));
+      testdesc.name = test;
+      testdesc.user_cmp_function = XCAR (prop);
+      testdesc.user_hash_function = XCAR (XCDR (prop));
+      testdesc.hashfn = hashfn_user_defined;
+      testdesc.cmpfn = cmpfn_user_defined;
     }
-  else
-    user_test = user_hash = Qnil;
 
   /* See if there's a `:size SIZE' argument.  */
   i = get_key_arg (QCsize, nargs, args, used);
@@ -4373,8 +4340,7 @@ usage: (make-hash-table &rest KEYWORD-ARGS)  */)
     if (!used[i])
       signal_error ("Invalid argument list", args[i]);
 
-  return make_hash_table (test, size, rehash_size, rehash_threshold, weak,
-                          user_test, user_hash);
+  return make_hash_table (testdesc, size, rehash_size, rehash_threshold, weak);
 }
 
 
@@ -4428,7 +4394,7 @@ DEFUN ("hash-table-test", Fhash_table_test, Shash_table_test, 1, 1, 0,
        doc: /* Return the test TABLE uses.  */)
   (Lisp_Object table)
 {
-  return check_hash_table (table)->test;
+  return check_hash_table (table)->test.name;
 }
 
 
@@ -4992,4 +4958,14 @@ this variable.  */);
   defsubr (&Smd5);
   defsubr (&Ssecure_hash);
   defsubr (&Slocale_info);
+
+  {
+    struct hash_table_test
+      eq = { Qeq, Qnil, Qnil, NULL, hashfn_eq },
+      eql = { Qeql, Qnil, Qnil, cmpfn_eql, hashfn_eql },
+      equal = { Qequal, Qnil, Qnil, cmpfn_equal, hashfn_equal };
+    hashtest_eq = eq;
+    hashtest_eql = eql;
+    hashtest_equal = equal;
+  }
 }
diff --git a/src/frame.c b/src/frame.c
index 52be8be270e..d580bf7f148 100644
--- a/src/frame.c
+++ b/src/frame.c
@@ -906,7 +906,7 @@ DEFUN ("frame-list", Fframe_list, Sframe_list,
 static Lisp_Object
 next_frame (Lisp_Object frame, Lisp_Object minibuf)
 {
-  Lisp_Object tail;
+  Lisp_Object f, tail;
   int passed = 0;
 
   /* There must always be at least one frame in Vframe_list.  */
@@ -918,12 +918,8 @@ next_frame (Lisp_Object frame, Lisp_Object minibuf)
   CHECK_LIVE_FRAME (frame);
 
   while (1)
-    for (tail = Vframe_list; CONSP (tail); tail = XCDR (tail))
+    FOR_EACH_FRAME (tail, f)
       {
-        Lisp_Object f;
-
-        f = XCAR (tail);
-
         if (passed
             && ((!FRAME_TERMCAP_P (XFRAME (f)) && !FRAME_TERMCAP_P (XFRAME (frame))
                  && FRAME_KBOARD (XFRAME (f)) == FRAME_KBOARD (XFRAME (frame)))
@@ -984,22 +980,13 @@ next_frame (Lisp_Object frame, Lisp_Object minibuf)
 static Lisp_Object
 prev_frame (Lisp_Object frame, Lisp_Object minibuf)
 {
-  Lisp_Object tail;
-  Lisp_Object prev;
+  Lisp_Object f, tail, prev = Qnil;
 
   /* There must always be at least one frame in Vframe_list.  */
-  if (! CONSP (Vframe_list))
-    emacs_abort ();
+  eassert (CONSP (Vframe_list));
 
-  prev = Qnil;
-  for (tail = Vframe_list; CONSP (tail); tail = XCDR (tail))
+  FOR_EACH_FRAME (tail, f)
     {
-      Lisp_Object f;
-
-      f = XCAR (tail);
-      if (!FRAMEP (f))
-        emacs_abort ();
-
       if (EQ (frame, f) && !NILP (prev))
         return prev;
 
@@ -1100,11 +1087,10 @@ Otherwise, include all frames.  */)
 static int
 other_visible_frames (FRAME_PTR f)
 {
-  Lisp_Object frames;
+  Lisp_Object frames, this;
 
-  for (frames = Vframe_list; CONSP (frames); frames = XCDR (frames))
+  FOR_EACH_FRAME (frames, this)
     {
-      Lisp_Object this = XCAR (frames);
       if (f == XFRAME (this))
         continue;
 
@@ -1158,15 +1144,10 @@ delete_frame (Lisp_Object frame, Lisp_Object force)
      minibuffer for any other frame?  */
   if (FRAME_HAS_MINIBUF_P (f))
     {
-      Lisp_Object frames;
+      Lisp_Object frames, this;
 
-      for (frames = Vframe_list;
-           CONSP (frames);
-           frames = XCDR (frames))
+      FOR_EACH_FRAME (frames, this)
         {
-          Lisp_Object this;
-          this = XCAR (frames);
-
           if (! EQ (this, frame)
               && EQ (frame,
                      WINDOW_FRAME (XWINDOW
@@ -1359,15 +1340,13 @@ delete_frame (Lisp_Object frame, Lisp_Object force)
      another one.  */
   if (f == last_nonminibuf_frame)
     {
-      Lisp_Object frames;
+      Lisp_Object frames, this;
 
       last_nonminibuf_frame = 0;
 
-      for (frames = Vframe_list;
-           CONSP (frames);
-           frames = XCDR (frames))
+      FOR_EACH_FRAME (frames, this)
         {
-          f = XFRAME (XCAR (frames));
+          f = XFRAME (this);
           if (!FRAME_MINIBUF_ONLY_P (f))
             {
               last_nonminibuf_frame = f;
@@ -1380,27 +1359,13 @@ delete_frame (Lisp_Object frame, Lisp_Object force)
      single-kboard state if we're in it for this kboard.  */
   if (kb != NULL)
     {
-      Lisp_Object frames;
+      Lisp_Object frames, this;
       /* Some frame we found on the same kboard, or nil if there are none.  */
-      Lisp_Object frame_on_same_kboard;
-
-      frame_on_same_kboard = Qnil;
-
-      for (frames = Vframe_list;
-           CONSP (frames);
-           frames = XCDR (frames))
-        {
-          Lisp_Object this;
-          struct frame *f1;
-
-          this = XCAR (frames);
-          if (!FRAMEP (this))
-            emacs_abort ();
-          f1 = XFRAME (this);
+      Lisp_Object frame_on_same_kboard = Qnil;
 
-          if (kb == FRAME_KBOARD (f1))
-            frame_on_same_kboard = this;
-        }
+      FOR_EACH_FRAME (frames, this)
+        if (kb == FRAME_KBOARD (XFRAME (this)))
+          frame_on_same_kboard = this;
 
       if (NILP (frame_on_same_kboard))
         not_single_kboard_state (kb);
@@ -1412,27 +1377,16 @@ delete_frame (Lisp_Object frame, Lisp_Object force)
      frames with other windows.  */
   if (kb != NULL && EQ (frame, KVAR (kb, Vdefault_minibuffer_frame)))
     {
-      Lisp_Object frames;
+      Lisp_Object frames, this;
 
       /* The last frame we saw with a minibuffer, minibuffer-only or not.  */
-      Lisp_Object frame_with_minibuf;
+      Lisp_Object frame_with_minibuf = Qnil;
       /* Some frame we found on the same kboard, or nil if there are none.  */
-      Lisp_Object frame_on_same_kboard;
+      Lisp_Object frame_on_same_kboard = Qnil;
 
-      frame_on_same_kboard = Qnil;
-      frame_with_minibuf = Qnil;
-
-      for (frames = Vframe_list;
-           CONSP (frames);
-           frames = XCDR (frames))
+      FOR_EACH_FRAME (frames, this)
         {
-          Lisp_Object this;
-          struct frame *f1;
-
-          this = XCAR (frames);
-          if (!FRAMEP (this))
-            emacs_abort ();
-          f1 = XFRAME (this);
+          struct frame *f1 = XFRAME (this);
 
           /* Consider only frames on the same kboard
              and only those with minibuffers.  */
@@ -1816,20 +1770,12 @@ DEFUN ("visible-frame-list", Fvisible_frame_list, Svisible_frame_list,
        doc: /* Return a list of all frames now \"visible\" (being updated).  */)
   (void)
 {
-  Lisp_Object tail, frame;
-  struct frame *f;
-  Lisp_Object value;
+  Lisp_Object tail, frame, value = Qnil;
+
+  FOR_EACH_FRAME (tail, frame)
+    if (FRAME_VISIBLE_P (XFRAME (frame)))
+      value = Fcons (frame, value);
 
-  value = Qnil;
-  for (tail = Vframe_list; CONSP (tail); tail = XCDR (tail))
-    {
-      frame = XCAR (tail);
-      if (!FRAMEP (frame))
-        continue;
-      f = XFRAME (frame);
-      if (FRAME_VISIBLE_P (f))
-        value = Fcons (frame, value);
-    }
   return value;
 }
 
diff --git a/src/frame.h b/src/frame.h
index 1dc3ebbaf13..35cbc44becc 100644
--- a/src/frame.h
+++ b/src/frame.h
@@ -237,7 +237,7 @@ struct frame
 
 #if defined (USE_GTK) || defined (HAVE_NS)
   /* Nonzero means using a tool bar that comes from the toolkit.  */
-  int external_tool_bar;
+  unsigned external_tool_bar : 1;
 #endif
 
   /* Margin at the top of the frame.  Used to display the tool-bar.  */
diff --git a/src/image.c b/src/image.c
index 538ae2b7772..07db6cece1f 100644
--- a/src/image.c
+++ b/src/image.c
@@ -3731,10 +3731,10 @@ xpm_make_color_table_h (void (**put_func) (Lisp_Object,
 {
   *put_func = xpm_put_color_table_h;
   *get_func = xpm_get_color_table_h;
-  return make_hash_table (Qequal, make_number (DEFAULT_HASH_SIZE),
+  return make_hash_table (hashtest_equal, make_number (DEFAULT_HASH_SIZE),
                           make_float (DEFAULT_REHASH_SIZE),
                           make_float (DEFAULT_REHASH_THRESHOLD),
-                          Qnil, Qnil, Qnil);
+                          Qnil);
 }
 
 static void
diff --git a/src/keyboard.c b/src/keyboard.c
index 7507b29d494..42c26982086 100644
--- a/src/keyboard.c
+++ b/src/keyboard.c
@@ -3419,13 +3419,20 @@ int stop_character EXTERNALLY_VISIBLE;
 static KBOARD *
 event_to_kboard (struct input_event *event)
 {
-  Lisp_Object obj = event->frame_or_window;
-  /* There are some events that set this field to nil or string.  */
-  if (WINDOWP (obj))
-    obj = WINDOW_FRAME (XWINDOW (obj));
-  /* Also ignore dead frames here.  */
-  return ((FRAMEP (obj) && FRAME_LIVE_P (XFRAME (obj)))
-          ? FRAME_KBOARD (XFRAME (obj)) : NULL);
+  /* Not applicable for these special events.  */
+  if (event->kind == SELECTION_REQUEST_EVENT
+      || event->kind == SELECTION_CLEAR_EVENT)
+    return NULL;
+  else
+    {
+      Lisp_Object obj = event->frame_or_window;
+      /* There are some events that set this field to nil or string.  */
+      if (WINDOWP (obj))
+        obj = WINDOW_FRAME (XWINDOW (obj));
+      /* Also ignore dead frames here.  */
+      return ((FRAMEP (obj) && FRAME_LIVE_P (XFRAME (obj)))
+              ? FRAME_KBOARD (XFRAME (obj)) : NULL);
+    }
 }
 
 #ifdef subprocesses
diff --git a/src/lisp.h b/src/lisp.h
index 7a3b819116f..b56e499ce29 100644
--- a/src/lisp.h
+++ b/src/lisp.h
@@ -413,14 +413,11 @@ enum pvec_type
   PVEC_XWIDGET_VIEW,
 #endif
 
-  /* These last 4 are special because we OR them in fns.c:internal_equal,
-     so they have to use a disjoint bit pattern:
-     if (!(size & (PVEC_COMPILED | PVEC_CHAR_TABLE
-                   | PVEC_SUB_CHAR_TABLE | PVEC_FONT))) */
-  PVEC_COMPILED                 = 0x10,
-  PVEC_CHAR_TABLE               = 0x20,
-  PVEC_SUB_CHAR_TABLE           = 0x30,
-  PVEC_FONT                     = 0x40
+  /* These should be last, check internal_equal to see why.  */
+  PVEC_COMPILED,
+  PVEC_CHAR_TABLE,
+  PVEC_SUB_CHAR_TABLE,
+  PVEC_FONT /* Should be last because it's used for range checking.  */
 };
 
 /* DATA_SEG_BITS forces extra bits to be or'd in with any pointers
@@ -440,9 +437,18 @@ enum More_Lisp_Bits
        only the number of Lisp_Object fields (that need to be traced by GC).
        The distinction is used, e.g., by Lisp_Process, which places extra
        non-Lisp_Object fields at the end of the structure.  */
-    PSEUDOVECTOR_SIZE_BITS = 16,
+    PSEUDOVECTOR_SIZE_BITS = 12,
     PSEUDOVECTOR_SIZE_MASK = (1 << PSEUDOVECTOR_SIZE_BITS) - 1,
-    PVEC_TYPE_MASK = 0x0fff << PSEUDOVECTOR_SIZE_BITS,
+
+    /* To calculate the memory footprint of the pseudovector, it's useful
+       to store the size of non-Lisp area in word_size units here.  */
+    PSEUDOVECTOR_REST_BITS = 12,
+    PSEUDOVECTOR_REST_MASK = (((1 << PSEUDOVECTOR_REST_BITS) - 1)
+                              << PSEUDOVECTOR_SIZE_BITS),
+
+    /* Used to extract pseudovector subtype information.  */
+    PSEUDOVECTOR_AREA_BITS = PSEUDOVECTOR_SIZE_BITS + PSEUDOVECTOR_REST_BITS,
+    PVEC_TYPE_MASK = 0x3f << PSEUDOVECTOR_AREA_BITS,
 
     /* Number of bits to put in each character in the internal representation
        of bool vectors.  This should not vary across implementations.  */
@@ -453,9 +459,6 @@ enum More_Lisp_Bits
  For example, if tem is a Lisp_Object whose type is Lisp_Cons,
  XCONS (tem) is the struct Lisp_Cons * pointing to the memory for that cons.  */
 
-/* Return a perfect hash of the Lisp_Object representation.  */
-#define XHASH(a) XLI (a)
-
 #if USE_LSB_TAG
 
 enum lsb_bits
@@ -508,6 +511,11 @@ static EMACS_INT const VALMASK
 
 #endif /* not USE_LSB_TAG */
 
+/* Return a (Lisp-integer sized) hash of the Lisp_Object value.  Happens to be
+   like XUINT right now, but XUINT should only be applied to objects we know
+   are integers.  */
+#define XHASH(a) XUINT (a)
+
 /* For integers known to be positive, XFASTINT sometimes provides
    faster retrieval and XSETFASTINT provides faster storage.
    If not, fallback on the non-accelerated path.  */
@@ -523,7 +531,7 @@ static EMACS_INT const VALMASK
 # define XUNTAG(a, type) XPNTR (a)
 #endif
 
-#define EQ(x, y) (XHASH (x) == XHASH (y))
+#define EQ(x, y) (XLI (x) == XLI (y))
 
 /* Largest and smallest representable fixnum values.  These are the C
    values.  They are macros for use in static initializers.  */
@@ -613,13 +621,13 @@ clip_to_bounds (ptrdiff_t lower, EMACS_INT num, ptrdiff_t upper)
 
 /* Pseudovector types.  */
 
-#define XSETPVECTYPE(v, code) XSETTYPED_PVECTYPE (v, header.size, code)
-#define XSETTYPED_PVECTYPE(v, size_member, code) \
-  ((v)->size_member |= PSEUDOVECTOR_FLAG | ((code) << PSEUDOVECTOR_SIZE_BITS))
-#define XSETPVECTYPESIZE(v, code, sizeval) \
+#define XSETPVECTYPE(v, code)                                           \
+  ((v)->header.size |= PSEUDOVECTOR_FLAG | ((code) << PSEUDOVECTOR_AREA_BITS))
+#define XSETPVECTYPESIZE(v, code, lispsize, restsize)           \
   ((v)->header.size = (PSEUDOVECTOR_FLAG                        \
-                       | ((code) << PSEUDOVECTOR_SIZE_BITS)     \
-                       | (sizeval)))
+                       | ((code) << PSEUDOVECTOR_AREA_BITS)     \
+                       | ((restsize) << PSEUDOVECTOR_SIZE_BITS) \
+                       | (lispsize)))
 
 /* The cast to struct vectorlike_header * avoids aliasing issues.  */
 #define XSETPSEUDOVECTOR(a, b, code) \
@@ -631,16 +639,14 @@ clip_to_bounds (ptrdiff_t lower, EMACS_INT num, ptrdiff_t upper)
 #define XSETTYPED_PSEUDOVECTOR(a, b, size, code)                        \
   (XSETVECTOR (a, b),                                                   \
    eassert ((size & (PSEUDOVECTOR_FLAG | PVEC_TYPE_MASK))               \
-            == (PSEUDOVECTOR_FLAG | (code << PSEUDOVECTOR_SIZE_BITS))))
+            == (PSEUDOVECTOR_FLAG | (code << PSEUDOVECTOR_AREA_BITS))))
 
 #define XSETWINDOW_CONFIGURATION(a, b) \
   (XSETPSEUDOVECTOR (a, b, PVEC_WINDOW_CONFIGURATION))
 #define XSETPROCESS(a, b) (XSETPSEUDOVECTOR (a, b, PVEC_PROCESS))
 #define XSETWINDOW(a, b) (XSETPSEUDOVECTOR (a, b, PVEC_WINDOW))
 #define XSETTERMINAL(a, b) (XSETPSEUDOVECTOR (a, b, PVEC_TERMINAL))
-/* XSETSUBR is special since Lisp_Subr lacks struct vectorlike_header.  */
-#define XSETSUBR(a, b) \
-  XSETTYPED_PSEUDOVECTOR (a, b, XSUBR (a)->size, PVEC_SUBR)
+#define XSETSUBR(a, b) (XSETPSEUDOVECTOR (a, b, PVEC_SUBR))
 #define XSETCOMPILED(a, b) (XSETPSEUDOVECTOR (a, b, PVEC_COMPILED))
 #define XSETBUFFER(a, b) (XSETPSEUDOVECTOR (a, b, PVEC_BUFFER))
 #define XSETCHAR_TABLE(a, b) (XSETPSEUDOVECTOR (a, b, PVEC_CHAR_TABLE))
@@ -807,7 +813,7 @@ struct Lisp_String
   };
 
 /* Header of vector-like objects.  This documents the layout constraints on
-   vectors and pseudovectors other than struct Lisp_Subr.  It also prevents
+   vectors and pseudovectors (objects of PVEC_xxx subtype).  It also prevents
    compilers from being fooled by Emacs's type punning: the XSETPSEUDOVECTOR
    and PSEUDOVECTORP macros cast their pointers to struct vectorlike_header *,
    because when two such pointers potentially alias, a compiler won't
@@ -815,43 +821,26 @@ struct Lisp_String
    <http://debbugs.gnu.org/cgi/bugreport.cgi?bug=8546>.  */
 struct vectorlike_header
   {
-    /* This field contains various pieces of information:
+    /* The only field contains various pieces of information:
        - The MSB (ARRAY_MARK_FLAG) holds the gcmarkbit.
        - The next bit (PSEUDOVECTOR_FLAG) indicates whether this is a plain
          vector (0) or a pseudovector (1).
        - If PSEUDOVECTOR_FLAG is 0, the rest holds the size (number
          of slots) of the vector.
-       - If PSEUDOVECTOR_FLAG is 1, the rest is subdivided into
-         a "pvec type" tag held in PVEC_TYPE_MASK and a size held in the lowest
-         PSEUDOVECTOR_SIZE_BITS.  That size normally indicates the number of
-         Lisp_Object slots at the beginning of the object that need to be
-         traced by the GC, tho some types use it slightly differently.
-       - E.g. if the pvec type is PVEC_FREE it means this is an unallocated
-         vector on a free-list and PSEUDOVECTOR_SIZE_BITS indicates its size
-         in bytes.  */
+       - If PSEUDOVECTOR_FLAG is 1, the rest is subdivided into three fields:
+         - a) pseudovector subtype held in PVEC_TYPE_MASK field;
+         - b) number of Lisp_Objects slots at the beginning of the object
+           held in PSEUDOVECTOR_SIZE_MASK field.  These objects are always
+           traced by the GC;
+         - c) size of the rest fields held in PSEUDOVECTOR_REST_MASK and
+           measured in word_size units.  Rest fields may also include
+           Lisp_Objects, but these objects usually needs some special treatment
+           during GC.
+         There are some exceptions.  For PVEC_FREE, b) is always zero.  For
+         PVEC_BOOL_VECTOR and PVEC_SUBR, both b) and c) are always zero.
+         Current layout limits the pseudovectors to 63 PVEC_xxx subtypes,
+         4095 Lisp_Objects in GC-ed area and 4095 word-sized other slots.  */
     ptrdiff_t size;
-
-    /* When the vector is allocated from a vector block, NBYTES is used
-       if the vector is not on a free list, and VECTOR is used otherwise.
-       For large vector-like objects, BUFFER or VECTOR is used as a pointer
-       to the next vector-like object.  It is generally a buffer or a
-       Lisp_Vector alias, so for convenience it is a union instead of a
-       pointer: this way, one can write P->next.vector instead of ((struct
-       Lisp_Vector *) P->next).  */
-    union {
-      /* This is only needed for small vectors that are not free because the
-         `size' field only gives us the number of Lisp_Object slots, whereas we
-         need to know the total size, including non-Lisp_Object data.
-         FIXME: figure out a way to store this info elsewhere so we can
-         finally get rid of this extra word of overhead.  */
-      ptrdiff_t nbytes;
-      struct buffer *buffer;
-      /* FIXME: This can be removed: For large vectors, this field could be
-         placed *before* the vector itself.  And for small vectors on a free
-         list, this field could be stored in the vector's bytes, since the
-         empty vector is handled specially anyway.  */
-      struct Lisp_Vector *vector;
-    } next;
   };
 
 /* Regular vector is just a header plus array of Lisp_Objects.  */
@@ -1025,15 +1014,11 @@ struct Lisp_Sub_Char_Table
 
 /* This structure describes a built-in function.
    It is generated by the DEFUN macro only.
-   defsubr makes it into a Lisp object.
-
-   This type is treated in most respects as a pseudovector,
-   but since we never dynamically allocate or free them,
-   we don't need a struct vectorlike_header and its 'next' field.  */
+   defsubr makes it into a Lisp object.  */
 
 struct Lisp_Subr
   {
-    ptrdiff_t size;
+    struct vectorlike_header header;
     union {
       Lisp_Object (*a0) (void);
       Lisp_Object (*a1) (Lisp_Object);
@@ -1181,14 +1166,29 @@ struct Lisp_Symbol
 
 /* The structure of a Lisp hash table.  */
 
+struct hash_table_test
+{
+  /* Name of the function used to compare keys.  */
+  Lisp_Object name;
+
+  /* User-supplied hash function, or nil.  */
+  Lisp_Object user_hash_function;
+
+  /* User-supplied key comparison function, or nil.  */
+  Lisp_Object user_cmp_function;
+
+  /* C function to compare two keys.  */
+  bool (*cmpfn) (struct hash_table_test *t, Lisp_Object, Lisp_Object);
+
+  /* C function to compute hash code.  */
+  EMACS_UINT (*hashfn) (struct hash_table_test *t, Lisp_Object);
+};
+
 struct Lisp_Hash_Table
 {
   /* This is for Lisp; the hash table code does not refer to it.  */
   struct vectorlike_header header;
 
-  /* Function used to compare keys.  */
-  Lisp_Object test;
-
   /* Nil if table is non-weak.  Otherwise a symbol describing the
      weakness of the table.  */
   Lisp_Object weak;
@@ -1219,12 +1219,6 @@ struct Lisp_Hash_Table
      hash table size to reduce collisions.  */
   Lisp_Object index;
 
-  /* User-supplied hash function, or nil.  */
-  Lisp_Object user_hash_function;
-
-  /* User-supplied key comparison function, or nil.  */
-  Lisp_Object user_cmp_function;
-
   /* Only the fields above are traced normally by the GC.  The ones below
      `count' are special and are either ignored by the GC or traced in
      a special way (e.g. because of weakness).  */
@@ -1237,17 +1231,12 @@ struct Lisp_Hash_Table
      This is gc_marked specially if the table is weak.  */
   Lisp_Object key_and_value;
 
+  /* The comparison and hash functions.  */
+  struct hash_table_test test;
+
   /* Next weak hash table if this is a weak hash table.  The head
      of the list is in weak_hash_tables.  */
   struct Lisp_Hash_Table *next_weak;
-
-  /* C function to compare two keys.  */
-  bool (*cmpfn) (struct Lisp_Hash_Table *,
-                 Lisp_Object, EMACS_UINT,
-                 Lisp_Object, EMACS_UINT);
-
-  /* C function to compute hash code.  */
-  EMACS_UINT (*hashfn) (struct Lisp_Hash_Table *, Lisp_Object);
 };
 
 
@@ -1302,6 +1291,15 @@ static double const DEFAULT_REHASH_THRESHOLD = 0.8;
 
 static double const DEFAULT_REHASH_SIZE = 1.5;
 
+/* Combine two integers X and Y for hashing.  The result might not fit
+   into a Lisp integer.  */
+
+LISP_INLINE EMACS_UINT
+sxhash_combine (EMACS_UINT x, EMACS_UINT y)
+{
+  return (x << 4) + (x >> (BITS_PER_EMACS_INT - 4)) + y;
+}
+
 /* These structures are used for various misc types.  */
 
 struct Lisp_Misc_Any            /* Supertype of all Misc types.  */
@@ -1701,6 +1699,8 @@ typedef struct {
 #define MARKERP(x) (MISCP (x) && XMISCTYPE (x) == Lisp_Misc_Marker)
 #define SAVE_VALUEP(x) (MISCP (x) && XMISCTYPE (x) == Lisp_Misc_Save_Value)
 
+#define AUTOLOADP(x) (CONSP (x) && EQ (Qautoload, XCAR (x)))
+
 #define INTFWDP(x) (XFWDTYPE (x) == Lisp_Fwd_Int)
 #define BOOLFWDP(x) (XFWDTYPE (x) == Lisp_Fwd_Bool)
 #define OBJFWDP(x) (XFWDTYPE (x) == Lisp_Fwd_Obj)
@@ -1714,7 +1714,7 @@ typedef struct {
 
 #define PSEUDOVECTOR_TYPEP(v, code)                                     \
   (((v)->size & (PSEUDOVECTOR_FLAG | PVEC_TYPE_MASK))                   \
-   == (PSEUDOVECTOR_FLAG | ((code) << PSEUDOVECTOR_SIZE_BITS)))
+   == (PSEUDOVECTOR_FLAG | ((code) << PSEUDOVECTOR_AREA_BITS)))
 
 /* True if object X, with internal type struct T *, is a pseudovector whose
    code is CODE.  */
@@ -1727,8 +1727,7 @@ typedef struct {
 #define PROCESSP(x) PSEUDOVECTORP (x, PVEC_PROCESS)
 #define WINDOWP(x) PSEUDOVECTORP (x, PVEC_WINDOW)
 #define TERMINALP(x) PSEUDOVECTORP (x, PVEC_TERMINAL)
-/* SUBRP is special since Lisp_Subr lacks struct vectorlike_header.  */
-#define SUBRP(x) TYPED_PSEUDOVECTORP (x, Lisp_Subr, PVEC_SUBR)
+#define SUBRP(x) PSEUDOVECTORP (x, PVEC_SUBR)
 #define COMPILEDP(x) PSEUDOVECTORP (x, PVEC_COMPILED)
 #define BUFFERP(x) PSEUDOVECTORP (x, PVEC_BUFFER)
 #define CHAR_TABLE_P(x) PSEUDOVECTORP (x, PVEC_CHAR_TABLE)
@@ -1903,8 +1902,8 @@ typedef struct {
 #define DEFUN(lname, fnname, sname, minargs, maxargs, intspec, doc)     \
    Lisp_Object fnname DEFUN_ARGS_ ## maxargs ;                          \
    static struct Lisp_Subr alignas (GCALIGNMENT) sname =                \
-   { (PVEC_SUBR << PSEUDOVECTOR_SIZE_BITS)                              \
-     | (sizeof (struct Lisp_Subr) / sizeof (EMACS_INT)),                \
+   { { (PVEC_SUBR << PSEUDOVECTOR_AREA_BITS)                            \
+       | (sizeof (struct Lisp_Subr) / sizeof (EMACS_INT)) },            \
       { (Lisp_Object (__cdecl *)(void))fnname },                        \
        minargs, maxargs, lname, intspec, 0};                            \
    Lisp_Object fnname
@@ -1912,8 +1911,8 @@ typedef struct {
 #define DEFUN(lname, fnname, sname, minargs, maxargs, intspec, doc)     \
    Lisp_Object fnname DEFUN_ARGS_ ## maxargs ;                          \
    static struct Lisp_Subr alignas (GCALIGNMENT) sname =                \
-     { PVEC_SUBR << PSEUDOVECTOR_SIZE_BITS,                             \
-      { .a ## maxargs = fnname },                                       \
+     { { PVEC_SUBR << PSEUDOVECTOR_AREA_BITS },                         \
+       { .a ## maxargs = fnname },                                      \
        minargs, maxargs, lname, intspec, 0};                            \
    Lisp_Object fnname
 #endif
@@ -2727,15 +2726,15 @@ extern Lisp_Object larger_vector (Lisp_Object, ptrdiff_t, ptrdiff_t);
 extern void sweep_weak_hash_tables (void);
 extern Lisp_Object Qcursor_in_echo_area;
 extern Lisp_Object Qstring_lessp;
-extern Lisp_Object QCsize, QCtest, QCweakness, Qequal, Qeq, Qeql;
+extern Lisp_Object QCsize, QCtest, QCweakness, Qequal, Qeq;
 EMACS_UINT hash_string (char const *, ptrdiff_t);
 EMACS_UINT sxhash (Lisp_Object, int);
-Lisp_Object make_hash_table (Lisp_Object, Lisp_Object, Lisp_Object,
-                             Lisp_Object, Lisp_Object, Lisp_Object,
-                             Lisp_Object);
+Lisp_Object make_hash_table (struct hash_table_test, Lisp_Object, Lisp_Object,
+                             Lisp_Object, Lisp_Object);
 ptrdiff_t hash_lookup (struct Lisp_Hash_Table *, Lisp_Object, EMACS_UINT *);
 ptrdiff_t hash_put (struct Lisp_Hash_Table *, Lisp_Object, Lisp_Object,
                     EMACS_UINT);
+extern struct hash_table_test hashtest_eql, hashtest_equal;
 
 extern Lisp_Object substring_both (Lisp_Object, ptrdiff_t, ptrdiff_t,
                                    ptrdiff_t, ptrdiff_t);
@@ -2957,7 +2956,7 @@ extern void make_byte_code (struct Lisp_Vector *);
 extern Lisp_Object Qautomatic_gc;
 extern Lisp_Object Qchar_table_extra_slots;
 extern struct Lisp_Vector *allocate_vector (EMACS_INT);
-extern struct Lisp_Vector *allocate_pseudovector (int memlen, int lisplen, int tag);
+extern struct Lisp_Vector *allocate_pseudovector (int, int, enum pvec_type);
 #define ALLOCATE_PSEUDOVECTOR(typ,field,tag)                            \
   ((typ*)                                                               \
    allocate_pseudovector                                                \
diff --git a/src/lread.c b/src/lread.c
index 94744620279..3a82e0057e2 100644
--- a/src/lread.c
+++ b/src/lread.c
@@ -3981,7 +3981,7 @@ defsubr (struct Lisp_Subr *sname)
 {
   Lisp_Object sym, tem;
   sym = intern_c_string (sname->symbol_name);
-  XSETTYPED_PVECTYPE (sname, size, PVEC_SUBR);
+  XSETPVECTYPE (sname, PVEC_SUBR);
   XSETSUBR (tem, sname);
   set_symbol_function (sym, tem);
 }
diff --git a/src/nsfont.m b/src/nsfont.m
index 4f29d1d54a9..2ba38b7570e 100644
--- a/src/nsfont.m
+++ b/src/nsfont.m
@@ -46,8 +46,9 @@ Author: Adrian Robert (arobert@cogsci.ucsd.edu)
 #define NSFONT_TRACE 0
 
 extern Lisp_Object Qns;
-extern Lisp_Object Qnormal, Qbold, Qitalic, Qcondensed, Qexpanded;
+extern Lisp_Object Qnormal, Qbold, Qitalic;
 static Lisp_Object Qapple, Qroman, Qmedium;
+static Lisp_Object Qcondensed, Qexpanded;
 extern Lisp_Object Qappend;
 extern float ns_antialias_threshold;
 extern int ns_tmp_flags;
@@ -201,8 +202,8 @@ ns_descriptor_to_entity (NSFontDescriptor *desc,
                     make_number (100 + 100
                          * ns_attribute_fvalue (desc, NSFontSlantTrait)));*/
     FONT_SET_STYLE (font_entity, FONT_WIDTH_INDEX,
-                    traits & NSFontCondensedTrait ? Qcondensed :
-                    traits & NSFontExpandedTrait ? Qexpanded : Qnormal);
+                    traits & NSFontCondensedTrait ? Qcondensed :
+                    traits & NSFontExpandedTrait ? Qexpanded : Qnormal);
 /*    FONT_SET_STYLE (font_entity, FONT_WIDTH_INDEX,
                     make_number (100 + 100
                          * ns_attribute_fvalue (desc, NSFontWidthTrait)));*/
@@ -559,7 +560,11 @@ ns_findfonts (Lisp_Object font_spec, BOOL isMatch)
     if (isMatch)
         [fkeys removeObject: NSFontFamilyAttribute];
 
-    matchingDescs = [fdesc matchingFontDescriptorsWithMandatoryKeys: fkeys];
+    if ([fkeys count] > 0)
+      matchingDescs = [fdesc matchingFontDescriptorsWithMandatoryKeys: fkeys];
+    else
+      matchingDescs = [NSMutableArray array];
+
     if (NSFONT_TRACE)
         NSLog(@"Got desc %@ and found %d matching fonts from it: ", fdesc,
               [matchingDescs count]);
@@ -1507,6 +1512,8 @@ syms_of_nsfont (void)
 {
   nsfont_driver.type = Qns;
   register_font_driver (&nsfont_driver, NULL);
+  DEFSYM (Qcondensed, "condensed");
+  DEFSYM (Qexpanded, "expanded");
   DEFSYM (Qapple, "apple");
   DEFSYM (Qroman, "roman");
   DEFSYM (Qmedium, "medium");
diff --git a/src/print.c b/src/print.c
index 22ed47bf65f..0788d110784 100644
--- a/src/print.c
+++ b/src/print.c
@@ -800,7 +800,7 @@ safe_debug_print (Lisp_Object arg)
   else
     fprintf (stderr, "#<%s_LISP_OBJECT 0x%08"pI"x>\r\n",
              !valid ? "INVALID" : "SOME",
-             XHASH (arg));
+             XLI (arg));
 }
 
 
@@ -1824,14 +1824,14 @@ print_object (Lisp_Object obj, register Lisp_Object printcharfun, int escapeflag
 #endif
           /* Implement a readable output, e.g.:
             #s(hash-table size 2 test equal data (k1 v1 k2 v2)) */
-          /* Always print the size. */
+          /* Always print the size.  */
           len = sprintf (buf, "#s(hash-table size %"pD"d", ASIZE (h->next));
           strout (buf, len, len, printcharfun);
 
-          if (!NILP (h->test))
+          if (!NILP (h->test.name))
             {
               strout (" test ", -1, -1, printcharfun);
-              print_object (h->test, printcharfun, escapeflag);
+              print_object (h->test.name, printcharfun, escapeflag);
             }
 
           if (!NILP (h->weak))
diff --git a/src/profiler.c b/src/profiler.c
index 51580710f28..3d8f7243d2f 100644
--- a/src/profiler.c
+++ b/src/profiler.c
@@ -35,6 +35,9 @@ saturated_add (EMACS_INT a, EMACS_INT b)
 
 typedef struct Lisp_Hash_Table log_t;
 
+static Lisp_Object Qprofiler_backtrace_equal;
+static struct hash_table_test hashtest_profiler;
+
 static Lisp_Object
 make_log (int heap_size, int max_stack_depth)
 {
@@ -42,10 +45,11 @@ make_log (int heap_size, int max_stack_depth)
      a special way.  This is OK as long as the object is not exposed
      to Elisp, i.e. until it is returned by *-profiler-log, after which
      it can't be used any more.  */
-  Lisp_Object log = make_hash_table (Qequal, make_number (heap_size),
+  Lisp_Object log = make_hash_table (hashtest_profiler,
+                                     make_number (heap_size),
                                      make_float (DEFAULT_REHASH_SIZE),
                                      make_float (DEFAULT_REHASH_THRESHOLD),
-                                     Qnil, Qnil, Qnil);
+                                     Qnil);
   struct Lisp_Hash_Table *h = XHASH_TABLE (log);
 
   /* What is special about our hash-tables is that the keys are pre-filled
@@ -238,8 +242,6 @@ handle_profiler_signal (int signal)
     cpu_gc_count = saturated_add (cpu_gc_count, 1);
   else
     {
-      Lisp_Object oquit;
-      bool saved_pending_signals;
       EMACS_INT count = 1;
 #ifdef HAVE_ITIMERSPEC
       if (profiler_timer_ok)
@@ -249,19 +251,8 @@ handle_profiler_signal (int signal)
           count += overruns;
         }
 #endif
-      /* record_backtrace uses hash functions that call Fequal, which
-         uses QUIT, which can call malloc, which can cause disaster in
-         a signal handler.  So inhibit QUIT.  */
-      oquit = Vinhibit_quit;
-      saved_pending_signals = pending_signals;
-      Vinhibit_quit = Qt;
-      pending_signals = 0;
-
       eassert (HASH_TABLE_P (cpu_log));
       record_backtrace (XHASH_TABLE (cpu_log), count);
-
-      Vinhibit_quit = oquit;
-      pending_signals = saved_pending_signals;
     }
 }
 
@@ -515,6 +506,66 @@ malloc_probe (size_t size)
   record_backtrace (XHASH_TABLE (memory_log), min (size, MOST_POSITIVE_FIXNUM));
 }
 
+DEFUN ("function-equal", Ffunction_equal, Sfunction_equal, 2, 2, 0,
+       doc: /* Return non-nil if F1 and F2 come from the same source.
+Used to determine if different closures are just different instances of
+the same lambda expression, or are really unrelated function.  */)
+     (Lisp_Object f1, Lisp_Object f2)
+{
+  bool res;
+  if (EQ (f1, f2))
+    res = true;
+  else if (COMPILEDP (f1) && COMPILEDP (f2))
+    res = EQ (AREF (f1, COMPILED_BYTECODE), AREF (f2, COMPILED_BYTECODE));
+  else if (CONSP (f1) && CONSP (f2) && CONSP (XCDR (f1)) && CONSP (XCDR (f2))
+           && EQ (Qclosure, XCAR (f1))
+           && EQ (Qclosure, XCAR (f2)))
+    res = EQ (XCDR (XCDR (f1)), XCDR (XCDR (f2)));
+  else
+    res = false;
+  return res ? Qt : Qnil;
+}
+
+static bool
+cmpfn_profiler (struct hash_table_test *t,
+                Lisp_Object bt1, Lisp_Object bt2)
+{
+  if (VECTORP (bt1) && VECTORP (bt2))
+    {
+      ptrdiff_t i, l = ASIZE (bt1);
+      if (l != ASIZE (bt2))
+        return false;
+      for (i = 0; i < l; i++)
+        if (NILP (Ffunction_equal (AREF (bt1, i), AREF (bt2, i))))
+          return false;
+      return true;
+    }
+  else
+    return EQ (bt1, bt2);
+}
+
+static EMACS_UINT
+hashfn_profiler (struct hash_table_test *ht, Lisp_Object bt)
+{
+  if (VECTORP (bt))
+    {
+      EMACS_UINT hash = 0;
+      ptrdiff_t i, l = ASIZE (bt);
+      for (i = 0; i < l; i++)
+        {
+          Lisp_Object f = AREF (bt, i);
+          EMACS_UINT hash1
+            = (COMPILEDP (f) ? XHASH (AREF (f, COMPILED_BYTECODE))
+               : (CONSP (f) && CONSP (XCDR (f)) && EQ (Qclosure, XCAR (f)))
+               ? XHASH (XCDR (XCDR (f))) : XHASH (f));
+          hash = sxhash_combine (hash, hash1);
+        }
+      return (hash & INTMASK);
+    }
+  else
+    return XHASH (bt);
+}
+
 void
 syms_of_profiler (void)
 {
@@ -527,6 +578,16 @@ If the log gets full, some of the least-seen call-stacks will be evicted
 to make room for new entries.  */);
   profiler_log_size = 10000;
 
+  DEFSYM (Qprofiler_backtrace_equal, "profiler-backtrace-equal");
+  {
+    struct hash_table_test test
+      = { Qprofiler_backtrace_equal, Qnil, Qnil,
+          cmpfn_profiler, hashfn_profiler };
+    hashtest_profiler = test;
+  }
+
+  defsubr (&Sfunction_equal);
+
 #ifdef PROFILER_CPU_SUPPORT
   profiler_cpu_running = NOT_RUNNING;
   cpu_log = Qnil;
diff --git a/src/ralloc.c b/src/ralloc.c
index 11897411930..e5bf76b0e6d 100644
--- a/src/ralloc.c
+++ b/src/ralloc.c
@@ -327,6 +327,8 @@ relinquish (void)
 
       if ((char *)last_heap->end - (char *)last_heap->bloc_start <= excess)
         {
+          heap_ptr lh_prev;
+
           /* This heap should have no blocs in it.  If it does, we
              cannot return it to the system.  */
           if (last_heap->first_bloc != NIL_BLOC
@@ -335,28 +337,26 @@ relinquish (void)
 
           /* Return the last heap, with its header, to the system.  */
           excess = (char *)last_heap->end - (char *)last_heap->start;
-          last_heap = last_heap->prev;
-          last_heap->next = NIL_HEAP;
+          lh_prev = last_heap->prev;
+          /* If the system doesn't want that much memory back, leave
+             last_heap unaltered to reflect that.  This can occur if
+             break_value is still within the original data segment.  */
+          if ((*real_morecore) (- excess) != 0)
+            {
+              last_heap = lh_prev;
+              last_heap->next = NIL_HEAP;
+            }
         }
       else
         {
           excess = (char *) last_heap->end
                         - (char *) ROUNDUP ((char *)last_heap->end - excess);
-          last_heap->end = (char *) last_heap->end - excess;
-        }
-
-      if ((*real_morecore) (- excess) == 0)
-        {
-          /* If the system didn't want that much memory back, adjust
-             the end of the last heap to reflect that.  This can occur
-             if break_value is still within the original data segment.  */
-          last_heap->end = (char *) last_heap->end + excess;
-          /* Make sure that the result of the adjustment is accurate.
-             It should be, for the else clause above; the other case,
-             which returns the entire last heap to the system, seems
-             unlikely to trigger this mode of failure.  */
-          if (last_heap->end != (*real_morecore) (0))
-            emacs_abort ();
+          /* If the system doesn't want that much memory back, leave
+             the end of the last heap unchanged to reflect that.  This
+             can occur if break_value is still within the original
+             data segment.  */
+          if ((*real_morecore) (- excess) != 0)
+            last_heap->end = (char *) last_heap->end - excess;
         }
     }
 }
diff --git a/src/regex.c b/src/regex.c
index 7443eff3977..1473551e6cc 100644
--- a/src/regex.c
+++ b/src/regex.c
@@ -28,7 +28,7 @@
      rather than at run-time, so that re_match can be reentrant.
 */
 
-/* AIX requires this to be the first thing in the file. */
+/* AIX requires this to be the first thing in the file.  */
 #if defined _AIX && !defined REGEX_MALLOC
   #pragma alloca
 #endif
diff --git a/src/termhooks.h b/src/termhooks.h
index 256ba26e435..d4b472cfb24 100644
--- a/src/termhooks.h
+++ b/src/termhooks.h
@@ -417,14 +417,6 @@ struct terminal
   int memory_below_frame;       /* Terminal remembers lines scrolled
                                    off bottom */
 
-#if 0  /* These are not used anywhere. */
-  /* EMACS_INT baud_rate; */    /* Output speed in baud */
-  int min_padding_speed;        /* Speed below which no padding necessary. */
-  int dont_calculate_costs;     /* Nonzero means don't bother computing
-                                   various cost tables; we won't use them. */
-#endif
-
-
   /* Window-based redisplay interface for this device (0 for tty
      devices). */
   struct redisplay_interface *rif;
@@ -472,10 +464,7 @@ struct terminal
      Otherwise, set *bar_window to Qnil, and *x and *y to the column and
      row of the character cell the mouse is over.
 
-     Set *time to the time the mouse was at the returned position.
-
-     This should clear mouse_moved until the next motion
-     event arrives.  */
+     Set *time to the time the mouse was at the returned position.  */
   void (*mouse_position_hook) (struct frame **f, int,
                                Lisp_Object *bar_window,
                                enum scroll_bar_part *part,
@@ -483,11 +472,6 @@ struct terminal
                                Lisp_Object *y,
                                Time *);
 
-  /* The window system handling code should set this if the mouse has
-     moved since the last call to the mouse_position_hook.  Calling that
-     hook should clear this.  */
-  int mouse_moved;
-
   /* When a frame's focus redirection is changed, this hook tells the
      window system code to re-decide where to put the highlight.  Under
      X, this means that Emacs lies about where the focus is.  */
diff --git a/src/w32fns.c b/src/w32fns.c
index f4f5aad90b4..ed5625e802c 100644
--- a/src/w32fns.c
+++ b/src/w32fns.c
@@ -304,19 +304,14 @@ check_x_display_info (Lisp_Object frame)
 /* Return the Emacs frame-object corresponding to an w32 window.
    It could be the frame's main window or an icon window.  */
 
-/* This function can be called during GC, so use GC_xxx type test macros.  */
-
 struct frame *
 x_window_to_frame (struct w32_display_info *dpyinfo, HWND wdesc)
 {
   Lisp_Object tail, frame;
   struct frame *f;
 
-  for (tail = Vframe_list; CONSP (tail); tail = XCDR (tail))
+  FOR_EACH_FRAME (tail, frame)
     {
-      frame = XCAR (tail);
-      if (!FRAMEP (frame))
-        continue;
       f = XFRAME (frame);
       if (!FRAME_W32_P (f) || FRAME_W32_DISPLAY_INFO (f) != dpyinfo)
         continue;
@@ -2085,6 +2080,12 @@ sync_modifiers (void)
 static int
 modifier_set (int vkey)
 {
+  /* Warning: The fact that VK_NUMLOCK is not treated as the other 2
+     toggle keys is not an omission!  If you want to add it, you will
+     have to make changes in the default sub-case of the WM_KEYDOWN
+     switch, because if the NUMLOCK modifier is set, the code there
+     will directly convert any key that looks like an ASCII letter,
+     and also downcase those that look like upper-case ASCII.  */
   if (vkey == VK_CAPITAL)
     {
       if (NILP (Vw32_enable_caps_lock))
@@ -2094,7 +2095,15 @@ modifier_set (int vkey)
     }
   if (vkey == VK_SCROLL)
     {
-      if (NILP (Vw32_scroll_lock_modifier))
+      if (NILP (Vw32_scroll_lock_modifier)
+          /* w32-scroll-lock-modifier can be any non-nil value that is
+             not one of the modifiers, in which case it shall be ignored.  */
+          || !(   EQ (Vw32_scroll_lock_modifier, Qhyper)
+               || EQ (Vw32_scroll_lock_modifier, Qsuper)
+               || EQ (Vw32_scroll_lock_modifier, Qmeta)
+               || EQ (Vw32_scroll_lock_modifier, Qalt)
+               || EQ (Vw32_scroll_lock_modifier, Qcontrol)
+               || EQ (Vw32_scroll_lock_modifier, Qshift)))
         return 0;
       else
         return (GetKeyState (vkey) & 0x1);
diff --git a/src/w32term.c b/src/w32term.c
index 4cc0b860947..032912c27f4 100644
--- a/src/w32term.c
+++ b/src/w32term.c
@@ -3437,16 +3437,11 @@ w32_handle_tool_bar_click (struct frame *f, struct input_event *button_event)
 static struct scroll_bar *
 x_window_to_scroll_bar (Window window_id)
 {
-  Lisp_Object tail;
+  Lisp_Object tail, frame;
 
-  for (tail = Vframe_list; CONSP (tail); tail = XCDR (tail))
+  FOR_EACH_FRAME (tail, frame)
     {
-      Lisp_Object frame, bar, condemned;
-
-      frame = XCAR (tail);
-      /* All elements of Vframe_list should be frames.  */
-      if (! FRAMEP (frame))
-        emacs_abort ();
+      Lisp_Object bar, condemned;
 
       /* Scan this frame's scroll bar list for a scroll bar with the
          right window ID.  */
@@ -3626,7 +3621,7 @@ x_scroll_bar_create (struct window *w, int top, int left, int width, int height)
   HWND hwnd;
   SCROLLINFO si;
   struct scroll_bar *bar
-    = XSCROLL_BAR (Fmake_vector (make_number (SCROLL_BAR_VEC_SIZE), Qnil));
+    = XSCROLL_BAR (Fmake_vector (make_number (VECSIZE (struct scroll_bar)), Qnil));
   Lisp_Object barobj;
 
   block_input ();
diff --git a/src/w32term.h b/src/w32term.h
index af5b37a1171..72fb8a76e35 100644
--- a/src/w32term.h
+++ b/src/w32term.h
@@ -415,9 +415,8 @@ extern struct w32_output w32term_display;
 
 struct scroll_bar {
 
-  /* These fields are shared by all vectors.  */
-  EMACS_INT size_from_Lisp_Vector_struct;
-  struct Lisp_Vector *next_from_Lisp_Vector_struct;
+  /* This field is shared by all vectors.  */
+  struct vectorlike_header header;
 
   /* The window we're a scroll bar for.  */
   Lisp_Object window;
@@ -460,12 +459,6 @@ struct scroll_bar {
   Lisp_Object fringe_extended_p;
 };
 
-/* The number of elements a vector holding a struct scroll_bar needs.  */
-#define SCROLL_BAR_VEC_SIZE                                     \
-  ((sizeof (struct scroll_bar)                                  \
-    - sizeof (EMACS_INT) - sizeof (struct Lisp_Vector *))       \
-   / word_size)
-
 /* Turning a lisp vector value into a pointer to a struct scroll_bar.  */
 #define XSCROLL_BAR(vec) ((struct scroll_bar *) XVECTOR (vec))
 
diff --git a/src/window.c b/src/window.c
index 514119abef5..4c798ad4570 100644
--- a/src/window.c
+++ b/src/window.c
@@ -274,7 +274,7 @@ decode_valid_window (register Lisp_Object window)
 /* Build a frequently used 4-integer (X Y W H) list.  */
 
 static Lisp_Object
-quad (EMACS_INT x, EMACS_INT y, EMACS_INT w, EMACS_INT h)
+list4i (EMACS_INT x, EMACS_INT y, EMACS_INT w, EMACS_INT h)
 {
   return list4 (make_number (x), make_number (y),
                 make_number (w), make_number (h));
@@ -619,11 +619,13 @@ internal windows only.  */)
 
 DEFUN ("set-window-combination-limit", Fset_window_combination_limit, Sset_window_combination_limit, 2, 2, 0,
        doc: /* Set combination limit of window WINDOW to LIMIT; return LIMIT.
-WINDOW must be a valid window and defaults to the selected one.
 If LIMIT is nil, child windows of WINDOW can be recombined with WINDOW's
 siblings.  LIMIT t means that child windows of WINDOW are never
 \(re-)combined with WINDOW's siblings.  Other values are reserved for
-future use.  */)
+future use.
+
+WINDOW must be a valid window.  Setting the combination limit is
+meaningful for internal windows only.  */)
   (Lisp_Object window, Lisp_Object limit)
 {
   wset_combination_limit (decode_valid_window (window), limit);
@@ -883,8 +885,8 @@ header line, and/or mode line.  For the edges of just the text area, use
 {
   register struct window *w = decode_valid_window (window);
 
-  return quad (WINDOW_LEFT_EDGE_COL (w), WINDOW_TOP_EDGE_LINE (w),
-               WINDOW_RIGHT_EDGE_COL (w), WINDOW_BOTTOM_EDGE_LINE (w));
+  return list4i (WINDOW_LEFT_EDGE_COL (w), WINDOW_TOP_EDGE_LINE (w),
+                 WINDOW_RIGHT_EDGE_COL (w), WINDOW_BOTTOM_EDGE_LINE (w));
 }
 
 DEFUN ("window-pixel-edges", Fwindow_pixel_edges, Swindow_pixel_edges, 0, 1, 0,
@@ -903,8 +905,8 @@ of just the text area, use `window-inside-pixel-edges'.  */)
 {
   register struct window *w = decode_valid_window (window);
 
-  return quad (WINDOW_LEFT_EDGE_X (w), WINDOW_TOP_EDGE_Y (w),
-               WINDOW_RIGHT_EDGE_X (w), WINDOW_BOTTOM_EDGE_Y (w));
+  return list4i (WINDOW_LEFT_EDGE_X (w), WINDOW_TOP_EDGE_Y (w),
+                 WINDOW_RIGHT_EDGE_X (w), WINDOW_BOTTOM_EDGE_Y (w));
 }
 
 static void
@@ -949,10 +951,10 @@ of just the text area, use `window-inside-absolute-pixel-edges'.  */)
 
   calc_absolute_offset (w, &add_x, &add_y);
 
-  return quad (WINDOW_LEFT_EDGE_X (w) + add_x,
-               WINDOW_TOP_EDGE_Y (w) + add_y,
-               WINDOW_RIGHT_EDGE_X (w) + add_x,
-               WINDOW_BOTTOM_EDGE_Y (w) + add_y);
+  return list4i (WINDOW_LEFT_EDGE_X (w) + add_x,
+                 WINDOW_TOP_EDGE_Y (w) + add_y,
+                 WINDOW_RIGHT_EDGE_X (w) + add_x,
+                 WINDOW_BOTTOM_EDGE_Y (w) + add_y);
 }
 
 DEFUN ("window-inside-edges", Fwindow_inside_edges, Swindow_inside_edges, 0, 1, 0,
@@ -971,16 +973,16 @@ display margins, fringes, header line, and/or mode line.  */)
 {
   register struct window *w = decode_live_window (window);
 
-  return quad (WINDOW_BOX_LEFT_EDGE_COL (w)
-               + WINDOW_LEFT_MARGIN_COLS (w)
-               + WINDOW_LEFT_FRINGE_COLS (w),
-               WINDOW_TOP_EDGE_LINE (w)
-               + WINDOW_HEADER_LINE_LINES (w),
-               WINDOW_BOX_RIGHT_EDGE_COL (w)
-               - WINDOW_RIGHT_MARGIN_COLS (w)
-               - WINDOW_RIGHT_FRINGE_COLS (w),
-               WINDOW_BOTTOM_EDGE_LINE (w)
-               - WINDOW_MODE_LINE_LINES (w));
+  return list4i ((WINDOW_BOX_LEFT_EDGE_COL (w)
+                  + WINDOW_LEFT_MARGIN_COLS (w)
+                  + WINDOW_LEFT_FRINGE_COLS (w)),
+                 (WINDOW_TOP_EDGE_LINE (w)
+                  + WINDOW_HEADER_LINE_LINES (w)),
+                 (WINDOW_BOX_RIGHT_EDGE_COL (w)
+                  - WINDOW_RIGHT_MARGIN_COLS (w)
+                  - WINDOW_RIGHT_FRINGE_COLS (w)),
+                 (WINDOW_BOTTOM_EDGE_LINE (w)
+                  - WINDOW_MODE_LINE_LINES (w)));
 }
 
 DEFUN ("window-inside-pixel-edges", Fwindow_inside_pixel_edges, Swindow_inside_pixel_edges, 0, 1, 0,
@@ -998,16 +1000,16 @@ display margins, fringes, header line, and/or mode line.  */)
 {
   register struct window *w = decode_live_window (window);
 
-  return quad (WINDOW_BOX_LEFT_EDGE_X (w)
-               + WINDOW_LEFT_MARGIN_WIDTH (w)
-               + WINDOW_LEFT_FRINGE_WIDTH (w),
-               WINDOW_TOP_EDGE_Y (w)
-               + WINDOW_HEADER_LINE_HEIGHT (w),
-               WINDOW_BOX_RIGHT_EDGE_X (w)
-               - WINDOW_RIGHT_MARGIN_WIDTH (w)
-               - WINDOW_RIGHT_FRINGE_WIDTH (w),
-               WINDOW_BOTTOM_EDGE_Y (w)
-               - WINDOW_MODE_LINE_HEIGHT (w));
+  return list4i ((WINDOW_BOX_LEFT_EDGE_X (w)
+                  + WINDOW_LEFT_MARGIN_WIDTH (w)
+                  + WINDOW_LEFT_FRINGE_WIDTH (w)),
+                 (WINDOW_TOP_EDGE_Y (w)
+                  + WINDOW_HEADER_LINE_HEIGHT (w)),
+                 (WINDOW_BOX_RIGHT_EDGE_X (w)
+                  - WINDOW_RIGHT_MARGIN_WIDTH (w)
+                  - WINDOW_RIGHT_FRINGE_WIDTH (w)),
+                 (WINDOW_BOTTOM_EDGE_Y (w)
+                  - WINDOW_MODE_LINE_HEIGHT (w)));
 }
 
 DEFUN ("window-inside-absolute-pixel-edges",
@@ -1030,16 +1032,16 @@ display margins, fringes, header line, and/or mode line.  */)
 
   calc_absolute_offset (w, &add_x, &add_y);
 
-  return quad (WINDOW_BOX_LEFT_EDGE_X (w)
-               + WINDOW_LEFT_MARGIN_WIDTH (w)
-               + WINDOW_LEFT_FRINGE_WIDTH (w) + add_x,
-               WINDOW_TOP_EDGE_Y (w)
-               + WINDOW_HEADER_LINE_HEIGHT (w) + add_y,
-               WINDOW_BOX_RIGHT_EDGE_X (w)
-               - WINDOW_RIGHT_MARGIN_WIDTH (w)
-               - WINDOW_RIGHT_FRINGE_WIDTH (w) + add_x,
-               WINDOW_BOTTOM_EDGE_Y (w)
-               - WINDOW_MODE_LINE_HEIGHT (w) + add_y);
+  return list4i ((WINDOW_BOX_LEFT_EDGE_X (w)
+                  + WINDOW_LEFT_MARGIN_WIDTH (w)
+                  + WINDOW_LEFT_FRINGE_WIDTH (w) + add_x),
+                 (WINDOW_TOP_EDGE_Y (w)
+                  + WINDOW_HEADER_LINE_HEIGHT (w) + add_y),
+                 (WINDOW_BOX_RIGHT_EDGE_X (w)
+                  - WINDOW_RIGHT_MARGIN_WIDTH (w)
+                  - WINDOW_RIGHT_FRINGE_WIDTH (w) + add_x),
+                 (WINDOW_BOTTOM_EDGE_Y (w)
+                  - WINDOW_MODE_LINE_HEIGHT (w) + add_y));
 }
 
 /* Test if the character at column X, row Y is within window W.
@@ -1620,7 +1622,7 @@ display row, and VPOS is the row number (0-based) containing POS.  */)
     {
       Lisp_Object part = Qnil;
       if (!fully_p)
-        part = quad (rtop, rbot, rowh, vpos);
+        part = list4i (rtop, rbot, rowh, vpos);
       in_window = Fcons (make_number (x),
                          Fcons (make_number (y), part));
     }
@@ -1686,17 +1688,18 @@ Return nil if window display is not up-to-date.  In that case, use
       if (!WINDOW_WANTS_HEADER_LINE_P (w))
         return Qnil;
       row = MATRIX_HEADER_LINE_ROW (w->current_matrix);
-      return row->enabled_p ? quad (row->height, 0, 0, 0) : Qnil;
+      return row->enabled_p ? list4i (row->height, 0, 0, 0) : Qnil;
     }
 
   if (EQ (line, Qmode_line))
     {
       row = MATRIX_MODE_LINE_ROW (w->current_matrix);
       return (row->enabled_p ?
-              quad (row->height,
-                    0, /* not accurate */
-                    WINDOW_HEADER_LINE_HEIGHT (w)
-                    + window_text_bottom_y (w), 0)
+              list4i (row->height,
+                      0, /* not accurate */
+                      (WINDOW_HEADER_LINE_HEIGHT (w)
+                       + window_text_bottom_y (w)),
+                      0)
               : Qnil);
     }
 
@@ -1726,7 +1729,7 @@ Return nil if window display is not up-to-date.  In that case, use
 
  found_row:
   crop = max (0, (row->y + row->height) - max_y);
-  return quad (row->height + min (0, row->y) - crop, i, row->y, crop);
+  return list4i (row->height + min (0, row->y) - crop, i, row->y, crop);
 }
 
 DEFUN ("window-dedicated-p", Fwindow_dedicated_p, Swindow_dedicated_p,
@@ -2131,10 +2134,10 @@ window_list (void)
 {
   if (!CONSP (Vwindow_list))
     {
-      Lisp_Object tail;
+      Lisp_Object tail, frame;
 
       Vwindow_list = Qnil;
-      for (tail = Vframe_list; CONSP (tail); tail = XCDR (tail))
+      FOR_EACH_FRAME (tail, frame)
         {
           Lisp_Object args[2];
 
@@ -2142,7 +2145,7 @@ window_list (void)
              new windows at the front of args[1], which means we
              have to reverse this list at the end.  */
           args[1] = Qnil;
-          foreach_window (XFRAME (XCAR (tail)), add_window_to_list, &args[1]);
+          foreach_window (XFRAME (frame), add_window_to_list, &args[1]);
           args[0] = Vwindow_list;
           args[1] = Fnreverse (args[1]);
           Vwindow_list = Fnconc (2, args);
@@ -3870,9 +3873,10 @@ set correctly.  See the code of `split-window' for how this is done.  */)
 
       make_parent_window (old, horflag);
       p = XWINDOW (o->parent);
-      /* Store t in the new parent's combination_limit slot to avoid
-        that its children get merged into another window.  */
-      wset_combination_limit (p, Qt);
+      if (EQ (Vwindow_combination_limit, Qt))
+        /* Store t in the new parent's combination_limit slot to avoid
+           that its children get merged into another window.  */
+        wset_combination_limit (p, Qt);
       /* These get applied below.  */
       wset_new_total (p, horflag ? o->total_cols : o->total_lines);
       wset_new_normal (p, new_normal);
diff --git a/src/xdisp.c b/src/xdisp.c
index a98572bde72..67491c681b7 100644
--- a/src/xdisp.c
+++ b/src/xdisp.c
@@ -11150,17 +11150,15 @@ x_consider_frame_title (Lisp_Object frame)
       || f->explicit_name)
     {
       /* Do we have more than one visible frame on this X display?  */
-      Lisp_Object tail;
-      Lisp_Object fmt;
+      Lisp_Object tail, other_frame, fmt;
       ptrdiff_t title_start;
       char *title;
       ptrdiff_t len;
       struct it it;
       ptrdiff_t count = SPECPDL_INDEX ();
 
-      for (tail = Vframe_list; CONSP (tail); tail = XCDR (tail))
+      FOR_EACH_FRAME (tail, other_frame)
         {
-          Lisp_Object other_frame = XCAR (tail);
           struct frame *tf = XFRAME (other_frame);
 
           if (tf != f
@@ -14847,13 +14845,18 @@ try_scrolling (Lisp_Object window, int just_this_one_p,
           if (NUMBERP (aggressive))
             {
               double float_amount = XFLOATINT (aggressive) * height;
-              amount_to_scroll = float_amount;
-              if (amount_to_scroll == 0 && float_amount > 0)
-                amount_to_scroll = 1;
+              int aggressive_scroll = float_amount;
+              if (aggressive_scroll == 0 && float_amount > 0)
+                aggressive_scroll = 1;
               /* Don't let point enter the scroll margin near top of
-                 the window.  */
-              if (amount_to_scroll > height - 2*this_scroll_margin + dy)
-                amount_to_scroll = height - 2*this_scroll_margin + dy;
+                 the window.  This could happen if the value of
+                 scroll_up_aggressively is too large and there are
+                 non-zero margins, because scroll_up_aggressively
+                 means put point that fraction of window height
+                 _from_the_bottom_margin_.  */
+              if (aggressive_scroll + 2*this_scroll_margin > height)
+                aggressive_scroll = height - 2*this_scroll_margin;
+              amount_to_scroll = dy + aggressive_scroll;
             }
         }
 
@@ -14913,7 +14916,8 @@ try_scrolling (Lisp_Object window, int just_this_one_p,
           /* Compute the vertical distance from PT to the scroll
              margin position.  Move as far as scroll_max allows, or
              one screenful, or 10 screen lines, whichever is largest.
-             Give up if distance is greater than scroll_max.  */
+             Give up if distance is greater than scroll_max or if we
+             didn't reach the scroll margin position.  */
           SET_TEXT_POS (pos, PT, PT_BYTE);
           start_display (&it, w, pos);
           y0 = it.current_y;
@@ -14923,7 +14927,8 @@ try_scrolling (Lisp_Object window, int just_this_one_p,
                       y_to_move, -1,
                       MOVE_TO_POS | MOVE_TO_X | MOVE_TO_Y);
           dy = it.current_y - y0;
-          if (dy > scroll_max)
+          if (dy > scroll_max
+              || IT_CHARPOS (it) < CHARPOS (scroll_margin_pos))
             return SCROLLING_FAILED;
 
           /* Compute new window start.  */
@@ -14941,15 +14946,16 @@ try_scrolling (Lisp_Object window, int just_this_one_p,
               if (NUMBERP (aggressive))
                 {
                   double float_amount = XFLOATINT (aggressive) * height;
-                  amount_to_scroll = float_amount;
-                  if (amount_to_scroll == 0 && float_amount > 0)
-                    amount_to_scroll = 1;
-                  amount_to_scroll -=
-                    this_scroll_margin - dy - FRAME_LINE_HEIGHT (f);
+                  int aggressive_scroll = float_amount;
+                  if (aggressive_scroll == 0 && float_amount > 0)
+                    aggressive_scroll = 1;
                   /* Don't let point enter the scroll margin near
-                     bottom of the window.  */
-                  if (amount_to_scroll > height - 2*this_scroll_margin + dy)
-                    amount_to_scroll = height - 2*this_scroll_margin + dy;
+                     bottom of the window, if the value of
+                     scroll_down_aggressively happens to be too
+                     large.  */
+                  if (aggressive_scroll + 2*this_scroll_margin > height)
+                    aggressive_scroll = height - 2*this_scroll_margin;
+                  amount_to_scroll = dy + aggressive_scroll;
                 }
             }
 
@@ -29664,8 +29670,10 @@ start_hourglass (void)
     delay = make_emacs_time (DEFAULT_HOURGLASS_DELAY, 0);
 
 #ifdef HAVE_NTGUI
-  extern void w32_note_current_window (void);
-  w32_note_current_window ();
+  {
+    extern void w32_note_current_window (void);
+    w32_note_current_window ();
+  }
 #endif /* HAVE_NTGUI */
 
   hourglass_atimer = start_atimer (ATIMER_RELATIVE, delay,
diff --git a/src/xfaces.c b/src/xfaces.c
index 41c618612ac..daf329791c1 100644
--- a/src/xfaces.c
+++ b/src/xfaces.c
@@ -314,16 +314,10 @@ static Lisp_Object QCfontset;
 Lisp_Object Qnormal;
 Lisp_Object Qbold;
 static Lisp_Object Qline, Qwave;
-static Lisp_Object Qultra_light, Qreverse_oblique, Qreverse_italic;
 Lisp_Object Qextra_light, Qlight;
 Lisp_Object Qsemi_light, Qsemi_bold, Qextra_bold, Qultra_bold;
 Lisp_Object Qoblique;
 Lisp_Object Qitalic;
-static Lisp_Object Qultra_condensed, Qextra_condensed;
-Lisp_Object Qcondensed;
-static Lisp_Object Qsemi_condensed, Qsemi_expanded, Qextra_expanded;
-Lisp_Object Qexpanded;
-static Lisp_Object Qultra_expanded;
 static Lisp_Object Qreleased_button, Qpressed_button;
 static Lisp_Object QCstyle, QCcolor, QCline_width;
 Lisp_Object Qunspecified;       /* used in dosfns.c */
@@ -5018,17 +5012,14 @@ face for italic.  */)
   else
     {
       /* Find any frame on DISPLAY.  */
-      Lisp_Object fl_tail;
+      Lisp_Object tail;
 
       frame = Qnil;
-      for (fl_tail = Vframe_list; CONSP (fl_tail); fl_tail = XCDR (fl_tail))
-        {
-          frame = XCAR (fl_tail);
-          if (!NILP (Fequal (Fcdr (Fassq (Qdisplay,
-                                          XFRAME (frame)->param_alist)),
-                             display)))
-            break;
-        }
+      FOR_EACH_FRAME (tail, frame)
+        if (!NILP (Fequal (Fcdr (Fassq (Qdisplay,
+                                        XFRAME (frame)->param_alist)),
+                           display)))
+          break;
     }
 
   CHECK_LIVE_FRAME (frame);
@@ -6451,7 +6442,6 @@ syms_of_xfaces (void)
   DEFSYM (Qreleased_button, "released-button");
   DEFSYM (Qpressed_button, "pressed-button");
   DEFSYM (Qnormal, "normal");
-  DEFSYM (Qultra_light, "ultra-light");
   DEFSYM (Qextra_light, "extra-light");
   DEFSYM (Qlight, "light");
   DEFSYM (Qsemi_light, "semi-light");
@@ -6461,16 +6451,6 @@ syms_of_xfaces (void)
   DEFSYM (Qultra_bold, "ultra-bold");
   DEFSYM (Qoblique, "oblique");
   DEFSYM (Qitalic, "italic");
-  DEFSYM (Qreverse_oblique, "reverse-oblique");
-  DEFSYM (Qreverse_italic, "reverse-italic");
-  DEFSYM (Qultra_condensed, "ultra-condensed");
-  DEFSYM (Qextra_condensed, "extra-condensed");
-  DEFSYM (Qcondensed, "condensed");
-  DEFSYM (Qsemi_condensed, "semi-condensed");
-  DEFSYM (Qsemi_expanded, "semi-expanded");
-  DEFSYM (Qexpanded, "expanded");
-  DEFSYM (Qextra_expanded, "extra-expanded");
-  DEFSYM (Qultra_expanded, "ultra-expanded");
   DEFSYM (Qbackground_color, "background-color");
   DEFSYM (Qforeground_color, "foreground-color");
   DEFSYM (Qunspecified, "unspecified");
diff --git a/src/xfns.c b/src/xfns.c
index 82e218479c8..1f98e9fc8c7 100644
--- a/src/xfns.c
+++ b/src/xfns.c
@@ -224,13 +224,11 @@ x_window_to_frame (struct x_display_info *dpyinfo, int wdesc)
   Lisp_Object tail, frame;
   struct frame *f;
 
-  if (wdesc == None) return 0;
+  if (wdesc == None)
+    return NULL;
 
-  for (tail = Vframe_list; CONSP (tail); tail = XCDR (tail))
+  FOR_EACH_FRAME (tail, frame)
     {
-      frame = XCAR (tail);
-      if (!FRAMEP (frame))
-        continue;
       f = XFRAME (frame);
       if (!FRAME_X_P (f) || FRAME_X_DISPLAY_INFO (f) != dpyinfo)
         continue;
@@ -270,18 +268,16 @@ struct frame *
 x_any_window_to_frame (struct x_display_info *dpyinfo, int wdesc)
 {
   Lisp_Object tail, frame;
-  struct frame *f, *found;
+  struct frame *f, *found = NULL;
   struct x_output *x;
 
-  if (wdesc == None) return NULL;
+  if (wdesc == None)
+    return NULL;
 
-  found = NULL;
-  for (tail = Vframe_list; CONSP (tail) && !found; tail = XCDR (tail))
+  FOR_EACH_FRAME (tail, frame)
     {
-      frame = XCAR (tail);
-      if (!FRAMEP (frame))
-        continue;
-
+      if (found)
+        break;
       f = XFRAME (frame);
       if (FRAME_X_P (f) && FRAME_X_DISPLAY_INFO (f) == dpyinfo)
         {
@@ -325,13 +321,11 @@ x_menubar_window_to_frame (struct x_display_info *dpyinfo, XEvent *event)
   struct frame *f;
   struct x_output *x;
 
-  if (wdesc == None) return 0;
+  if (wdesc == None)
+    return NULL;
 
-  for (tail = Vframe_list; CONSP (tail); tail = XCDR (tail))
+  FOR_EACH_FRAME (tail, frame)
     {
-      frame = XCAR (tail);
-      if (!FRAMEP (frame))
-        continue;
       f = XFRAME (frame);
       if (!FRAME_X_P (f) || FRAME_X_DISPLAY_INFO (f) != dpyinfo)
         continue;
@@ -359,13 +353,11 @@ x_top_window_to_frame (struct x_display_info *dpyinfo, int wdesc)
   struct frame *f;
   struct x_output *x;
 
-  if (wdesc == None) return 0;
+  if (wdesc == None)
+    return NULL;
 
-  for (tail = Vframe_list; CONSP (tail); tail = XCDR (tail))
+  FOR_EACH_FRAME (tail, frame)
     {
-      frame = XCAR (tail);
-      if (!FRAMEP (frame))
-        continue;
       f = XFRAME (frame);
       if (!FRAME_X_P (f) || FRAME_X_DISPLAY_INFO (f) != dpyinfo)
         continue;
diff --git a/src/xmenu.c b/src/xmenu.c
index 01d932cf8d8..b585df2125b 100644
--- a/src/xmenu.c
+++ b/src/xmenu.c
@@ -132,11 +132,8 @@ menubar_id_to_frame (LWLIB_ID id)
   Lisp_Object tail, frame;
   FRAME_PTR f;
 
-  for (tail = Vframe_list; CONSP (tail); tail = XCDR (tail))
+  FOR_EACH_FRAME (tail, frame)
     {
-      frame = XCAR (tail);
-      if (!FRAMEP (frame))
-        continue;
       f = XFRAME (frame);
       if (!FRAME_WINDOW_P (f))
         continue;
diff --git a/src/xselect.c b/src/xselect.c
index de9386bd7d9..64c64fa0c76 100644
--- a/src/xselect.c
+++ b/src/xselect.c
@@ -1940,7 +1940,7 @@ x_handle_selection_notify (XSelectionEvent *event)
 static struct frame *
 frame_for_x_selection (Lisp_Object object)
 {
-  Lisp_Object tail;
+  Lisp_Object tail, frame;
   struct frame *f;
 
   if (NILP (object))
@@ -1949,9 +1949,9 @@ frame_for_x_selection (Lisp_Object object)
       if (FRAME_X_P (f) && FRAME_LIVE_P (f))
         return f;
 
-      for (tail = Vframe_list; CONSP (tail); tail = XCDR (tail))
+      FOR_EACH_FRAME (tail, frame)
         {
-          f = XFRAME (XCAR (tail));
+          f = XFRAME (frame);
           if (FRAME_X_P (f) && FRAME_LIVE_P (f))
             return f;
         }
@@ -1959,15 +1959,14 @@ frame_for_x_selection (Lisp_Object object)
   else if (TERMINALP (object))
     {
       struct terminal *t = get_terminal (object, 1);
+
       if (t->type == output_x_window)
-        {
-          for (tail = Vframe_list; CONSP (tail); tail = XCDR (tail))
-            {
-              f = XFRAME (XCAR (tail));
-              if (FRAME_LIVE_P (f) && f->terminal == t)
-                return f;
-            }
-        }
+        FOR_EACH_FRAME (tail, frame)
+          {
+            f = XFRAME (frame);
+            if (FRAME_LIVE_P (f) && f->terminal == t)
+              return f;
+          }
     }
   else if (FRAMEP (object))
     {
diff --git a/src/xterm.c b/src/xterm.c
index a36b008c105..ef0b2267dcd 100644
--- a/src/xterm.c
+++ b/src/xterm.c
@@ -1441,7 +1441,7 @@ static struct frame *
 x_frame_of_widget (Widget widget)
 {
   struct x_display_info *dpyinfo;
-  Lisp_Object tail;
+  Lisp_Object tail, frame;
   struct frame *f;
 
   dpyinfo = x_display_info_for_display (XtDisplay (widget));
@@ -1455,15 +1455,15 @@ x_frame_of_widget (Widget widget)
 
   /* Look for a frame with that top-level widget.  Allocate the color
      on that frame to get the right gamma correction value.  */
-  for (tail = Vframe_list; CONSP (tail); tail = XCDR (tail))
-    if (FRAMEP (XCAR (tail))
-        && (f = XFRAME (XCAR (tail)),
-            (FRAME_X_P (f)
-             && f->output_data.nothing != 1
-             && FRAME_X_DISPLAY_INFO (f) == dpyinfo))
-        && f->output_data.x->widget == widget)
-      return f;
-
+  FOR_EACH_FRAME (tail, frame)
+    {
+      f = XFRAME (frame);
+      if (FRAME_X_P (f)
+          && f->output_data.nothing != 1
+          && FRAME_X_DISPLAY_INFO (f) == dpyinfo
+          && f->output_data.x->widget == widget)
+        return f;
+    }
   emacs_abort ();
 }
 
@@ -4107,20 +4107,15 @@ XTmouse_position (FRAME_PTR *fp, int insist, Lisp_Object *bar_window,
 static struct scroll_bar *
 x_window_to_scroll_bar (Display *display, Window window_id)
 {
-  Lisp_Object tail;
+  Lisp_Object tail, frame;
 
 #if defined (USE_GTK) && defined (USE_TOOLKIT_SCROLL_BARS)
   window_id = (Window) xg_get_scroll_id_for_window (display, window_id);
 #endif /* USE_GTK  && USE_TOOLKIT_SCROLL_BARS */
 
-  for (tail = Vframe_list; CONSP (tail); tail = XCDR (tail))
+  FOR_EACH_FRAME (tail, frame)
     {
-      Lisp_Object frame, bar, condemned;
-
-      frame = XCAR (tail);
-      /* All elements of Vframe_list should be frames.  */
-      if (! FRAMEP (frame))
-        emacs_abort ();
+      Lisp_Object bar, condemned;
 
       if (! FRAME_X_P (XFRAME (frame)))
         continue;
@@ -4152,20 +4147,16 @@ x_window_to_scroll_bar (Display *display, Window window_id)
 static Widget
 x_window_to_menu_bar (Window window)
 {
-  Lisp_Object tail;
+  Lisp_Object tail, frame;
 
-  for (tail = Vframe_list; CONSP (tail); tail = XCDR (tail))
-    {
-      if (FRAME_X_P (XFRAME (XCAR (tail))))
-        {
-          Lisp_Object frame = XCAR (tail);
-          Widget menu_bar = XFRAME (frame)->output_data.x->menubar_widget;
-
-          if (menu_bar && xlwmenu_window_p (menu_bar, window))
-            return menu_bar;
-        }
-    }
+  FOR_EACH_FRAME (tail, frame)
+    if (FRAME_X_P (XFRAME (frame)))
+      {
+        Widget menu_bar = XFRAME (frame)->output_data.x->menubar_widget;
 
+        if (menu_bar && xlwmenu_window_p (menu_bar, window))
+          return menu_bar;
+      }
   return NULL;
 }
 
@@ -10886,10 +10877,10 @@ default is nil, which is the same as `super'.  */);
 
   DEFVAR_LISP ("x-keysym-table", Vx_keysym_table,
     doc: /* Hash table of character codes indexed by X keysym codes.  */);
-  Vx_keysym_table = make_hash_table (Qeql, make_number (900),
+  Vx_keysym_table = make_hash_table (hashtest_eql, make_number (900),
                                      make_float (DEFAULT_REHASH_SIZE),
                                      make_float (DEFAULT_REHASH_THRESHOLD),
-                                     Qnil, Qnil, Qnil);
+                                     Qnil);
 }
 
 #endif /* HAVE_X_WINDOWS */
diff --git a/src/xterm.h b/src/xterm.h
index 4bc8f9813ed..6ef3d11fe48 100644
--- a/src/xterm.h
+++ b/src/xterm.h
@@ -890,10 +890,8 @@ struct scroll_bar
    by this structure.  */
 
 /* For an event of kind SELECTION_REQUEST_EVENT,
-   this structure really describes the contents.
-   **Don't make this struct longer!**
-   If it overlaps the frame_or_window field of struct input_event,
-   that will cause GC to crash.  */
+   this structure really describes the contents.  */
+
 struct selection_input_event
 {
   int kind;