Add DOHASH_SAFE, make DOHASH faster (bug#68690)

Revert DOHASH to the fast (field-caching) implementation but with
an assertion to detect misuses.  Add DOHASH_SAFE for use in
code that must tolerate arbitrary mutation of the table being
iterated through.

* src/lisp.h (DOHASH): Go back to fast design that only allows
restricted mutation, but with a checking assertion.
(DOHASH_SAFE): New macro that tolerates arbitrary mutation while being
much simpler (and acceptably fast).
* src/fns.c (Fmaphash):
* src/comp.c (compile_function, Fcomp__compile_ctxt_to_file):
Use DOHASH_SAFE.

1 files changed, 13 insertions, 8 deletions

diff --git a/src/comp.c b/src/comp.c
index 5f28cf046b5..853757f6162 100644
--- a/src/comp.c
+++ b/src/comp.c
@@ -4330,9 +4330,12 @@ compile_function (Lisp_Object func)
   declare_block (Qentry);
   Lisp_Object blocks = CALL1I (comp-func-blocks, func);
   struct Lisp_Hash_Table *ht = XHASH_TABLE (blocks);
-  DOHASH (ht, block_name, block)
-    if (!EQ (block_name, Qentry))
-      declare_block (block_name);
+  DOHASH_SAFE (ht, i)
+    {
+      Lisp_Object block_name = HASH_KEY (ht, i);
+      if (!EQ (block_name, Qentry))
+        declare_block (block_name);
+    }
 
   gcc_jit_block_add_assignment (retrive_block (Qentry),
                                 NULL,
@@ -4340,8 +4343,10 @@ compile_function (Lisp_Object func)
                                 gcc_jit_lvalue_as_rvalue (comp.func_relocs));
 
 
-  DOHASH (ht, block_name, block)
+  DOHASH_SAFE (ht, i)
     {
+      Lisp_Object block_name = HASH_KEY (ht, i);
+      Lisp_Object block = HASH_VALUE (ht, i);
       Lisp_Object insns = CALL1I (comp-block-insns, block);
       if (NILP (block) || NILP (insns))
         xsignal1 (Qnative_ice,
@@ -4956,12 +4961,12 @@ DEFUN ("comp--compile-ctxt-to-file", Fcomp__compile_ctxt_to_file,
 
   struct Lisp_Hash_Table *func_h =
     XHASH_TABLE (CALL1I (comp-ctxt-funcs-h, Vcomp_ctxt));
-  DOHASH (func_h, k, v)
-    declare_function (v);
+  DOHASH_SAFE (func_h, i)
+    declare_function (HASH_VALUE (func_h, i));
   /* Compile all functions. Can't be done before because the
      relocation structs has to be already defined.  */
-  DOHASH (func_h, k, v)
-    compile_function (v);
+  DOHASH_SAFE (func_h, i)
+    compile_function (HASH_VALUE (func_h, i));
 
   /* Work around bug#46495 (GCC PR99126). */
 #if defined (WIDE_EMACS_INT)                                            \