1 files changed, 31 insertions, 17 deletions

diff --git a/src/alloc.c b/src/alloc.c
index 15bb65cf74f..16257469aa6 100644
--- a/src/alloc.c
+++ b/src/alloc.c
@@ -360,13 +360,13 @@ static struct gcstat
   object_ct total_intervals, total_free_intervals;
   object_ct total_buffers;
 
-  /* Size of the ancillary arrays of live hash-table objects.
+  /* Size of the ancillary arrays of live hash-table and obarray objects.
      The objects themselves are not included (counted as vectors above).  */
   byte_ct total_hash_table_bytes;
 } gcstat;
 
-/* Total size of ancillary arrays of all allocated hash-table objects,
-   both dead and alive.  This number is always kept up-to-date.  */
+/* Total size of ancillary arrays of all allocated hash-table and obarray
+   objects, both dead and alive.  This number is always kept up-to-date.  */
 static ptrdiff_t hash_table_allocated_bytes = 0;
 
 /* Points to memory space allocated as "spare", to be freed if we run
@@ -3443,7 +3443,7 @@ cleanup_vector (struct Lisp_Vector *vector)
         struct Lisp_Hash_Table *h = PSEUDOVEC_STRUCT (vector, Lisp_Hash_Table);
         if (h->table_size > 0)
           {
-            eassert (h->index_size > 1);
+            eassert (h->index_bits > 0);
             xfree (h->index);
             xfree (h->key_and_value);
             xfree (h->next);
@@ -3451,10 +3451,19 @@ cleanup_vector (struct Lisp_Vector *vector)
             ptrdiff_t bytes = (h->table_size * (2 * sizeof *h->key_and_value
                                                 + sizeof *h->hash
                                                 + sizeof *h->next)
-                               + h->index_size * sizeof *h->index);
+                               + hash_table_index_size (h) * sizeof *h->index);
             hash_table_allocated_bytes -= bytes;
           }
       }
+      break;
+    case PVEC_OBARRAY:
+      {
+        struct Lisp_Obarray *o = PSEUDOVEC_STRUCT (vector, Lisp_Obarray);
+        xfree (o->buckets);
+        ptrdiff_t bytes = obarray_size (o) * sizeof *o->buckets;
+        hash_table_allocated_bytes -= bytes;
+      }
+      break;
     /* Keep the switch exhaustive.  */
     case PVEC_NORMAL_VECTOR:
     case PVEC_FREE:
@@ -3951,7 +3960,7 @@ Its value is void, and its function definition and property list are nil.  */)
   if (symbol_free_list)
     {
       ASAN_UNPOISON_SYMBOL (symbol_free_list);
-      XSETSYMBOL (val, symbol_free_list);
+      val = make_lisp_symbol (symbol_free_list);
       symbol_free_list = symbol_free_list->u.s.next;
     }
   else
@@ -3967,7 +3976,7 @@ Its value is void, and its function definition and property list are nil.  */)
         }
 
       ASAN_UNPOISON_SYMBOL (&symbol_block->symbols[symbol_block_index]);
-      XSETSYMBOL (val, &symbol_block->symbols[symbol_block_index]);
+      val = make_lisp_symbol (&symbol_block->symbols[symbol_block_index]);
       symbol_block_index++;
     }
 
@@ -5632,7 +5641,8 @@ valid_lisp_object_p (Lisp_Object obj)
   return 0;
 }
 
-/* Like xmalloc, but makes allocation count toward the total consing.
+/* Like xmalloc, but makes allocation count toward the total consing
+   and hash table or obarray usage.
    Return NULL for a zero-sized allocation.  */
 void *
 hash_table_alloc_bytes (ptrdiff_t nbytes)
@@ -5959,7 +5969,8 @@ purecopy_hash_table (struct Lisp_Hash_Table *table)
       for (ptrdiff_t i = 0; i < nvalues; i++)
         pure->key_and_value[i] = purecopy (table->key_and_value[i]);
 
-      ptrdiff_t index_bytes = table->index_size * sizeof *table->index;
+      ptrdiff_t index_bytes = hash_table_index_size (table)
+                              * sizeof *table->index;
       pure->index = pure_alloc (index_bytes, -(int)sizeof *table->index);
       memcpy (pure->index, table->index, index_bytes);
     }
@@ -6033,8 +6044,7 @@ purecopy (Lisp_Object obj)
           return obj; /* Don't hash cons it.  */
         }
 
-      struct Lisp_Hash_Table *h = purecopy_hash_table (table);
-      XSET_HASH_TABLE (obj, h);
+      obj = make_lisp_hash_table (purecopy_hash_table (table));
     }
   else if (COMPILEDP (obj) || VECTORP (obj) || RECORDP (obj))
     {
@@ -7310,6 +7320,14 @@ process_mark_stack (ptrdiff_t base_sp)
                   break;
                 }
 
+              case PVEC_OBARRAY:
+                {
+                  struct Lisp_Obarray *o = (struct Lisp_Obarray *)ptr;
+                  set_vector_marked (ptr);
+                  mark_stack_push_values (o->buckets, obarray_size (o));
+                  break;
+                }
+
               case PVEC_CHAR_TABLE:
               case PVEC_SUB_CHAR_TABLE:
                 mark_char_table (ptr, (enum pvec_type) pvectype);
@@ -7380,12 +7398,8 @@ process_mark_stack (ptrdiff_t base_sp)
                 mark_stack_push_value (SYMBOL_VAL (ptr));
                 break;
               case SYMBOL_VARALIAS:
-                {
-                  Lisp_Object tem;
-                  XSETSYMBOL (tem, SYMBOL_ALIAS (ptr));
-                  mark_stack_push_value (tem);
-                  break;
-                }
+                mark_stack_push_value (make_lisp_symbol (SYMBOL_ALIAS (ptr)));
+                break;
               case SYMBOL_LOCALIZED:
                 {
                   struct Lisp_Buffer_Local_Value *blv = SYMBOL_BLV (ptr);