scratch/igc 1edd9d7c001 4/5: Implement key-or-value-weak hash tables

[Pip Cet]

branch: scratch/igc
commit 1edd9d7c001497e2416379901822cc510249fc54
Author: Pip Cet <pipcet@protonmail.com>
Commit: Pip Cet <pipcet@protonmail.com>

    Implement key-or-value-weak hash tables
    
    * src/fns.c (allocate_weak_hash_table)
    (maybe_resize_weak_hash_table): Handle `Weak_Key_Or_Value' casee
    (weak_hash_put): Call `Figc__add_extra_dependency'.
    (Fputhash): Call `Figc__remove_extra_dependency',
    `Figc__add_extra_dependency'.
    * src/igc.c (fix_weak_hash_table_strong_part)
    (fix_weak_hash_table_weak_part)
    (igc_alloc_weak_hash_table_strong_part)
    (igc_alloc_weak_hash_table_weak_part): Handle `Weak_Key_Or_Value' case
---
 src/fns.c | 22 +++++++++++++++++++++-
 src/igc.c |  7 ++++++-
 2 files changed, 27 insertions(+), 2 deletions(-)

diff --git a/src/fns.c b/src/fns.c
index 221e239c639..7df28588e2c 100644
--- a/src/fns.c
+++ b/src/fns.c
@@ -5508,6 +5508,7 @@ allocate_weak_hash_table (hash_table_weakness_t weak, 
ssize_t size, ssize_t inde
       ret->strong->index = ret->strong->entries + 3 * size;
       break;
     case Weak_Key_And_Value:
+    case Weak_Key_Or_Value:
       ret->strong->key = ret->weak->entries;
       ret->strong->value = ret->weak->entries + size;
       ret->strong->index = ret->strong->entries + 2 * size;
@@ -5661,6 +5662,7 @@ maybe_resize_weak_hash_table (struct Lisp_Weak_Hash_Table 
*h)
          strong->index = strong->entries + 3 * new_size;
          break;
        case Weak_Key_And_Value:
+       case Weak_Key_Or_Value:
          strong->key = weak->entries;
          strong->value = weak->entries + new_size;
          strong->index = strong->entries + 2 * new_size;
@@ -5742,6 +5744,12 @@ weak_hash_put (struct Lisp_Weak_Hash_Table *h, 
Lisp_Object key, Lisp_Object valu
   /* Increment count after resizing because resizing may fail.  */
   maybe_resize_weak_hash_table (h);
 
+  if (h->strong->weakness == Weak_Key_Or_Value)
+    {
+      /* This might add a key -> key dependency, which is fine.  */
+      Figc__add_extra_dependency (key, value, make_lisp_weak_hash_table (h));
+      Figc__add_extra_dependency (value, key, make_lisp_weak_hash_table (h));
+    }
   /* Store key/value in the key_and_value vector.  */
   ptrdiff_t i = XFIXNUM (h->strong->next_free);
   //eassert (hash_unused_entry_key_p (HASH_KEY (h, i)));
@@ -6546,7 +6554,19 @@ VALUE.  In any case, return VALUE.  */)
       Lisp_Object hash = weak_hash_from_key (wh, key);
       ptrdiff_t i = weak_hash_lookup_with_hash (wh, key, hash);
       if (i >= 0)
-       set_weak_hash_value_slot (wh, i, value);
+       {
+         if (wh->strong->weakness == Weak_Key_Or_Value)
+           {
+             Figc__remove_extra_dependency (key, value, table);
+             Figc__remove_extra_dependency (value, key, table);
+           }
+         set_weak_hash_value_slot (wh, i, value);
+         if (wh->strong->weakness == Weak_Key_Or_Value)
+           {
+             Figc__add_extra_dependency (key, value, table);
+             Figc__add_extra_dependency (value, key, table);
+           }
+       }
       else
        weak_hash_put (wh, key, value, hash);
       return value;
diff --git a/src/igc.c b/src/igc.c
index 916b3a84316..330be3fe088 100644
--- a/src/igc.c
+++ b/src/igc.c
@@ -2025,6 +2025,7 @@ fix_weak_hash_table_strong_part (mps_ss_t ss, struct 
Lisp_Weak_Hash_Table_Strong
            limit = 3 * XFIXNUM (t->table_size);
            break;
          case Weak_Key_And_Value:
+         case Weak_Key_Or_Value:
            limit = 2 * XFIXNUM (t->table_size);
            break;
          default:
@@ -2060,6 +2061,7 @@ fix_weak_hash_table_weak_part (mps_ss_t ss, struct 
Lisp_Weak_Hash_Table_Weak_Par
            limit = XFIXNUM (t->table_size);
            break;
          case Weak_Key_And_Value:
+         case Weak_Key_Or_Value:
            limit = 2 * XFIXNUM (t->table_size);
            break;
          default:
@@ -2080,7 +2082,8 @@ fix_weak_hash_table_weak_part (mps_ss_t ss, struct 
Lisp_Weak_Hash_Table_Weak_Par
                    .weak = w,
                  };
                weak_hash_splat_from_table
-                 (&pseudo_h, ((t->weakness == Weak_Key_And_Value) ?
+                 (&pseudo_h, ((t->weakness == Weak_Key_And_Value ||
+                               t->weakness == Weak_Key_Or_Value) ?
                               (i % XFIXNUM (t->table_size)) : i));
              }
          }
@@ -3965,6 +3968,7 @@ igc_alloc_weak_hash_table_strong_part 
(hash_table_weakness_t weak,
       total_size = 3 * size + ((ptrdiff_t)1 << index_bits);
       break;
     case Weak_Key_And_Value:
+    case Weak_Key_Or_Value:
       total_size = 2 * size + ((ptrdiff_t)1 << index_bits);
       break;
     default:
@@ -3989,6 +3993,7 @@ igc_alloc_weak_hash_table_weak_part 
(hash_table_weakness_t weak,
       total_size = size;
       break;
     case Weak_Key_And_Value:
+    case Weak_Key_Or_Value:
       total_size = 2 * size;
       break;
     default: