1 files changed, 96 insertions, 88 deletions

diff --git a/src/alloc.c b/src/alloc.c
index b1e2ed0a2ed..bd68f2b31f2 100644
--- a/src/alloc.c
+++ b/src/alloc.c
@@ -1529,7 +1529,7 @@ make_interval (void)
 }
 
 
-/* Mark Lisp objects in interval I. */
+/* Mark Lisp objects in interval I.  */
 
 static void
 mark_interval (register INTERVAL i, Lisp_Object dummy)
@@ -1836,7 +1836,7 @@ check_sblock (struct sblock *b)
       ptrdiff_t nbytes;
 
       /* Check that the string size recorded in the string is the
-         same as the one recorded in the sdata structure. */
+         same as the one recorded in the sdata structure.  */
       if (from->string)
         CHECK_STRING_BYTES (from->string);
 
@@ -2869,12 +2869,6 @@ DEFUN ("make-list", Fmake_list, Smake_list, 2, 2, 0,
 
 #define VECTOR_BLOCK_SIZE 4096
 
-/* This special value is used to calculate vector size when the vector is
-   on a free list.  It should be VECTOR_BLOCK_SIZE rounded up to nearest
-   power of two, minus one.  */
-
-#define VECTOR_FREE_LIST_SIZE_MASK 4095
-
 /* Handy constants for vectorlike objects.  */
 enum
   {
@@ -2889,8 +2883,7 @@ verify ((roundup_size & (roundup_size - 1)) == 0);
 
 /* Verify assumptions described above.  */
 verify ((VECTOR_BLOCK_SIZE % roundup_size) == 0);
-verify ((VECTOR_FREE_LIST_SIZE_MASK + 1) >= VECTOR_BLOCK_SIZE);
-verify ((VECTOR_FREE_LIST_SIZE_MASK & (VECTOR_FREE_LIST_SIZE_MASK + 1)) == 0);
+verify (VECTOR_BLOCK_SIZE <= (1 << PSEUDOVECTOR_SIZE_BITS));
 
 /* Round up X to nearest mult-of-ROUNDUP_SIZE.  */
 
@@ -2915,12 +2908,6 @@ verify ((VECTOR_FREE_LIST_SIZE_MASK & (VECTOR_FREE_LIST_SIZE_MASK + 1)) == 0);
 #define VECTOR_MAX_FREE_LIST_INDEX                              \
   ((VECTOR_BLOCK_BYTES - VBLOCK_BYTES_MIN) / roundup_size + 1)
 
-/* When the vector is on a free list, vectorlike_header.SIZE is set to
-   this special value ORed with vector's memory footprint size.  */
-
-#define VECTOR_FREE_LIST_FLAG (~(ARRAY_MARK_FLAG | PSEUDOVECTOR_FLAG    \
-                                 | VECTOR_FREE_LIST_SIZE_MASK))
-
 /* Common shortcut to advance vector pointer over a block data.  */
 
 #define ADVANCE(v, nbytes) ((struct Lisp_Vector *) ((char *) (v) + (nbytes)))
@@ -2933,7 +2920,7 @@ verify ((VECTOR_FREE_LIST_SIZE_MASK & (VECTOR_FREE_LIST_SIZE_MASK + 1)) == 0);
 
 #define SETUP_ON_FREE_LIST(v, nbytes, index)                    \
   do {                                                          \
-    (v)->header.size = VECTOR_FREE_LIST_FLAG | (nbytes);        \
+    XSETPVECTYPESIZE (v, PVEC_FREE, nbytes);                    \
     eassert ((nbytes) % roundup_size == 0);                     \
     (index) = VINDEX (nbytes);                                  \
     eassert ((index) < VECTOR_MAX_FREE_LIST_INDEX);             \
@@ -3065,6 +3052,16 @@ 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.  */
+
+#define PSEUDOVECTOR_NBYTES(vector) \
+  (PSEUDOVECTOR_TYPEP (&vector->header, PVEC_FREE)      \
+   ? vector->header.size & PSEUDOVECTOR_SIZE_MASK       \
+   : vector->header.next.nbytes);
+
 /* Reclaim space used by unmarked vectors.  */
 
 static void
@@ -3093,14 +3090,10 @@ sweep_vectors (void)
             }
           else
             {
-              ptrdiff_t nbytes;
+              ptrdiff_t nbytes = PSEUDOVECTOR_NBYTES (vector);
+              ptrdiff_t total_bytes = nbytes;
 
-              if ((vector->header.size & VECTOR_FREE_LIST_FLAG)
-                  == VECTOR_FREE_LIST_FLAG)
-                vector->header.next.nbytes =
-                  vector->header.size & VECTOR_FREE_LIST_SIZE_MASK;
-
-              next = ADVANCE (vector, vector->header.next.nbytes);
+              next = ADVANCE (vector, nbytes);
 
               /* While NEXT is not marked, try to coalesce with VECTOR,
                  thus making VECTOR of the largest possible size.  */
@@ -3109,16 +3102,12 @@ sweep_vectors (void)
                 {
                   if (VECTOR_MARKED_P (next))
                     break;
-                  if ((next->header.size & VECTOR_FREE_LIST_FLAG)
-                      == VECTOR_FREE_LIST_FLAG)
-                    nbytes = next->header.size & VECTOR_FREE_LIST_SIZE_MASK;
-                  else
-                    nbytes = next->header.next.nbytes;
-                  vector->header.next.nbytes += nbytes;
+                  nbytes = PSEUDOVECTOR_NBYTES (next);
+                  total_bytes += nbytes;
                   next = ADVANCE (next, nbytes);
                 }
 
-              eassert (vector->header.next.nbytes % roundup_size == 0);
+              eassert (total_bytes % roundup_size == 0);
 
               if (vector == (struct Lisp_Vector *) block->data
                   && !VECTOR_IN_BLOCK (next, block))
@@ -3126,7 +3115,10 @@ sweep_vectors (void)
                    space was coalesced into the only free vector.  */
                 free_this_block = 1;
               else
-                SETUP_ON_FREE_LIST (vector, vector->header.next.nbytes, nbytes);
+                {
+                  int tmp;
+                  SETUP_ON_FREE_LIST (vector, total_bytes, tmp);
+                }
             }
         }
 
@@ -4342,10 +4334,9 @@ live_vector_p (struct mem_node *m, void *p)
       while (VECTOR_IN_BLOCK (vector, block)
              && vector <= (struct Lisp_Vector *) p)
         {
-          if ((vector->header.size & VECTOR_FREE_LIST_FLAG)
-              == VECTOR_FREE_LIST_FLAG)
+          if (PSEUDOVECTOR_TYPEP (&vector->header, PVEC_FREE))
             vector = ADVANCE (vector, (vector->header.size
-                                       & VECTOR_FREE_LIST_SIZE_MASK));
+                                       & PSEUDOVECTOR_SIZE_MASK));
           else if (vector == p)
             return 1;
           else
@@ -5913,15 +5904,17 @@ mark_object (Lisp_Object arg)
 #endif /* GC_CHECK_MARKED_OBJECTS */
 
         if (ptr->header.size & PSEUDOVECTOR_FLAG)
-          pvectype = ptr->header.size & PVEC_TYPE_MASK;
+          pvectype = ((ptr->header.size & PVEC_TYPE_MASK)
+                      >> PSEUDOVECTOR_SIZE_BITS);
         else
           pvectype = 0;
 
         if (pvectype != PVEC_SUBR && pvectype != PVEC_BUFFER)
           CHECK_LIVE (live_vector_p);
 
-        if (pvectype == PVEC_BUFFER)
+        switch (pvectype)
           {
+          case PVEC_BUFFER:
 #ifdef GC_CHECK_MARKED_OBJECTS
             if (po != &buffer_defaults && po != &buffer_local_symbols)
               {
@@ -5933,67 +5926,82 @@ mark_object (Lisp_Object arg)
               }
 #endif /* GC_CHECK_MARKED_OBJECTS */
             mark_buffer ((struct buffer *) ptr);
-          }
+            break;
 
-        else if (pvectype == PVEC_COMPILED)
-          /* We could treat this just like a vector, but it is better
-             to save the COMPILED_CONSTANTS element for last and avoid
-             recursion there.  */
-          {
-            int size = ptr->header.size & PSEUDOVECTOR_SIZE_MASK;
-            int i;
+          case PVEC_COMPILED:
+            { /* We could treat this just like a vector, but it is better
+                 to save the COMPILED_CONSTANTS element for last and avoid
+                 recursion there.  */
+              int size = ptr->header.size & PSEUDOVECTOR_SIZE_MASK;
+              int i;
+
+              VECTOR_MARK (ptr);
+              for (i = 0; i < size; i++)
+                if (i != COMPILED_CONSTANTS)
+                  mark_object (ptr->contents[i]);
+              if (size > COMPILED_CONSTANTS)
+                {
+                  obj = ptr->contents[COMPILED_CONSTANTS];
+                  goto loop;
+                }
+            }
+            break;
 
-            VECTOR_MARK (ptr);
-            for (i = 0; i < size; i++)
-              if (i != COMPILED_CONSTANTS)
-                mark_object (ptr->contents[i]);
-            obj = ptr->contents[COMPILED_CONSTANTS];
-            goto loop;
-          }
+          case PVEC_FRAME:
+            {
+              mark_vectorlike (ptr);
+              mark_face_cache (((struct frame *) ptr)->face_cache);
+            }
+            break;
 
-        else if (pvectype == PVEC_FRAME)
-          {
-            mark_vectorlike (ptr);
-            mark_face_cache (((struct frame *) ptr)->face_cache);
-          }
+          case PVEC_WINDOW:
+            {
+              struct window *w = (struct window *) ptr;
 
-        else if (pvectype == PVEC_WINDOW)
-          {
-            struct window *w = (struct window *) ptr;
+              mark_vectorlike (ptr);
+              /* Mark glyphs for leaf windows.  Marking window
+                 matrices is sufficient because frame matrices
+                 use the same glyph memory.  */
+              if (NILP (w->hchild) && NILP (w->vchild) && w->current_matrix)
+                {
+                  mark_glyph_matrix (w->current_matrix);
+                  mark_glyph_matrix (w->desired_matrix);
+                }
+            }
+            break;
 
-            mark_vectorlike (ptr);
-            /* Mark glyphs for leaf windows.  Marking window
-               matrices is sufficient because frame matrices
-               use the same glyph memory.  */
-            if (NILP (w->hchild) && NILP (w->vchild) && w->current_matrix)
-              {
-                mark_glyph_matrix (w->current_matrix);
-                mark_glyph_matrix (w->desired_matrix);
-              }
-          }
+          case PVEC_HASH_TABLE:
+            {
+              struct Lisp_Hash_Table *h = (struct Lisp_Hash_Table *) ptr;
 
-        else if (pvectype == PVEC_HASH_TABLE)
-        {
-          struct Lisp_Hash_Table *h = (struct Lisp_Hash_Table *) ptr;
+              mark_vectorlike (ptr);
+              /* If hash table is not weak, mark all keys and values.
+                 For weak tables, mark only the vector.  */
+              if (NILP (h->weak))
+                mark_object (h->key_and_value);
+              else
+                VECTOR_MARK (XVECTOR (h->key_and_value));
+            }
+            break;
 
-          mark_vectorlike (ptr);
-          /* If hash table is not weak, mark all keys and values.
-             For weak tables, mark only the vector.  */
-          if (NILP (h->weak))
-            mark_object (h->key_and_value);
-          else
-            VECTOR_MARK (XVECTOR (h->key_and_value));
-        }
+          case PVEC_CHAR_TABLE:
+            mark_char_table (ptr);
+            break;
+
+          case PVEC_BOOL_VECTOR:
+            /* No Lisp_Objects to mark in a bool vector.  */
+            VECTOR_MARK (ptr);
+            break;
 
-        else if (pvectype == PVEC_CHAR_TABLE)
-          mark_char_table (ptr);
+          case PVEC_SUBR:
+            break;
 
-        else if (pvectype == PVEC_BOOL_VECTOR)
-          /* No Lisp_Objects to mark in a bool vector.  */
-          VECTOR_MARK (ptr);
+          case PVEC_FREE:
+            abort ();
 
-        else if (pvectype != PVEC_SUBR)
-          mark_vectorlike (ptr);
+          default:
+            mark_vectorlike (ptr);
+          }
       }
       break;