1 files changed, 18 insertions, 34 deletions

diff --git a/src/fns.c b/src/fns.c
index 557853d42fb..a96ddad1683 100644
--- a/src/fns.c
+++ b/src/fns.c
@@ -4280,13 +4280,13 @@ static void
 set_hash_next_slot (struct Lisp_Hash_Table *h, ptrdiff_t idx, ptrdiff_t val)
 {
   eassert (idx >= 0 && idx < h->table_size);
-  h->next[idx] = val;
+  h->hash_next[idx].next = val;
 }
 static void
 set_hash_hash_slot (struct Lisp_Hash_Table *h, ptrdiff_t idx, hash_hash_t val)
 {
   eassert (idx >= 0 && idx < h->table_size);
-  h->hash[idx] = val;
+  h->hash_next[idx].hash = val;
 }
 static void
 set_hash_index_slot (struct Lisp_Hash_Table *h, ptrdiff_t idx, ptrdiff_t val)
@@ -4383,7 +4383,7 @@ static ptrdiff_t
 HASH_NEXT (struct Lisp_Hash_Table *h, ptrdiff_t idx)
 {
   eassert (idx >= 0 && idx < h->table_size);
-  return h->next[idx];
+  return h->hash_next[idx].next;
 }
 
 /* Return the index of the element in hash table H that is the start
@@ -4571,8 +4571,7 @@ make_hash_table (const struct hash_table_test *test, EMACS_INT size,
   if (size == 0)
     {
       h->key_and_value = NULL;
-      h->hash = NULL;
-      h->next = NULL;
+      h->hash_next = NULL;
       eassert (index_size == 1);
       h->index = (hash_idx_t *)empty_hash_index_vector;
       h->next_free = -1;
@@ -4584,12 +4583,10 @@ make_hash_table (const struct hash_table_test *test, EMACS_INT size,
       for (ptrdiff_t i = 0; i < 2 * size; i++)
         h->key_and_value[i] = HASH_UNUSED_ENTRY_KEY;
 
-      h->hash = hash_table_alloc_bytes (size * sizeof *h->hash);
-
-      h->next = hash_table_alloc_bytes (size * sizeof *h->next);
+      h->hash_next = hash_table_alloc_bytes (size * sizeof *h->hash_next);
       for (ptrdiff_t i = 0; i < size - 1; i++)
-        h->next[i] = i + 1;
-      h->next[size - 1] = -1;
+        h->hash_next[i].next = i + 1;
+      h->hash_next[size - 1].next = -1;
 
       h->index = hash_table_alloc_bytes (index_size * sizeof *h->index);
       for (ptrdiff_t i = 0; i < index_size; i++)
@@ -4630,13 +4627,9 @@ copy_hash_table (struct Lisp_Hash_Table *h1)
       h2->key_and_value = hash_table_alloc_bytes (kv_bytes);
       memcpy (h2->key_and_value, h1->key_and_value, kv_bytes);
 
-      ptrdiff_t hash_bytes = h1->table_size * sizeof *h1->hash;
-      h2->hash = hash_table_alloc_bytes (hash_bytes);
-      memcpy (h2->hash, h1->hash, hash_bytes);
-
-      ptrdiff_t next_bytes = h1->table_size * sizeof *h1->next;
-      h2->next = hash_table_alloc_bytes (next_bytes);
-      memcpy (h2->next, h1->next, next_bytes);
+      ptrdiff_t hn_bytes = h1->table_size * sizeof *h1->hash_next;
+      h2->hash_next = hash_table_alloc_bytes (hn_bytes);
+      memcpy (h2->hash_next, h1->hash_next, hn_bytes);
 
       ptrdiff_t index_bytes = h1->index_size * sizeof *h1->index;
       h2->index = hash_table_alloc_bytes (index_bytes);
@@ -4674,11 +4667,12 @@ maybe_resize_hash_table (struct Lisp_Hash_Table *h)
 
       /* Allocate all the new vectors before updating *H, to
          avoid problems if memory is exhausted.  */
-      hash_idx_t *next = hash_table_alloc_bytes (new_size * sizeof *next);
-      memcpy (next, h->next, old_size * sizeof *next);
+      struct hash_next *hash_next
+        = hash_table_alloc_bytes (new_size * sizeof *hash_next);
+      memcpy (hash_next, h->hash_next, old_size * sizeof *hash_next);
       for (ptrdiff_t i = old_size; i < new_size - 1; i++)
-        next[i] = i + 1;
-      next[new_size - 1] = -1;
+        hash_next[i].next = i + 1;
+      hash_next[new_size - 1].next = -1;
 
       Lisp_Object *key_and_value
         = hash_table_alloc_bytes (2 * new_size * sizeof *key_and_value);
@@ -4687,9 +4681,6 @@ maybe_resize_hash_table (struct Lisp_Hash_Table *h)
       for (ptrdiff_t i = 2 * old_size; i < 2 * new_size; i++)
         key_and_value[i] = HASH_UNUSED_ENTRY_KEY;
 
-      hash_hash_t *hash = hash_table_alloc_bytes (new_size * sizeof *hash);
-      memcpy (hash, h->hash, old_size * sizeof *hash);
-
       ptrdiff_t old_index_size = h->index_size;
       ptrdiff_t index_size = hash_index_size (new_size);
       hash_idx_t *index = hash_table_alloc_bytes (index_size * sizeof *index);
@@ -4708,11 +4699,8 @@ maybe_resize_hash_table (struct Lisp_Hash_Table *h)
                              2 * old_size * sizeof *h->key_and_value);
       h->key_and_value = key_and_value;
 
-      hash_table_free_bytes (h->hash, old_size * sizeof *h->hash);
-      h->hash = hash;
-
-      hash_table_free_bytes (h->next, old_size * sizeof *h->next);
-      h->next = next;
+      hash_table_free_bytes (h->hash_next, old_size * sizeof *h->hash_next);
+      h->hash_next = hash_next;
 
       h->key_and_value = key_and_value;
 
@@ -4760,11 +4748,7 @@ hash_table_thaw (Lisp_Object hash_table)
   h->index_size = index_size;
   h->next_free = -1;
 
-  h->hash = hash_table_alloc_bytes (size * sizeof *h->hash);
-
-  h->next = hash_table_alloc_bytes (size * sizeof *h->next);
-  for (ptrdiff_t i = 0; i < size; i++)
-    h->next[i] = -1;
+  h->hash_next = hash_table_alloc_bytes (size * sizeof *h->hash_next);
 
   h->index = hash_table_alloc_bytes (index_size * sizeof *h->index);
   for (ptrdiff_t i = 0; i < index_size; i++)