It can be enabled with -DUSE_EPHEMERON_POOL.

This variant uses the ephemeron pool and hence sovles the key-in-value
problem.

This version stores key/values pairs a vector-of-pairs instead of a
pair-of-vectors.  The same vector-of-pairs type is used for weak and
non-weak.  This avoids the code duplication used by the pair-of-vector
version; though it adds a bit of overhead to the non-weak code path.

* src/lisp.h: (struct vector_pair [!USE_EPHEMERON_POOL]): New type.
(struct pair_vector [USE_EPHEMERON_POOL]):New type.
(hash_table_kv): New typedef used to both version.
(hash_table_kv_create, hash_table_kv_free, hash_table_kv_key)
(hash_table_kv_value, hash_table_kv_set_key, hash_table_kv_set_value)
(hash_table_kv_null): New helpers
(struct Lisp_Hash_Table): Use a single field kv of type hash_table_kv
instead of two fields.
(HASH_KEY, HASH_VALUE, WEAK_HASH_KEY, WEAK_HASH_VALUE, DOHASH)
(DOHASH_WEAK, set_hash_key_slot, set_hash_value_slot)
(set_weak_hash_key_slot, set_weak_hash_value_slot): Adapt to
hash_table_kv.
(DOHASH [USE_EPHEMERON_POOL]): New version.
* src/igc.h (enum igc_obj_type): Add IGC_OBJ_PAIR_VECTOR,
IGC_OBJ_WEAK_KEY_PAIR_VECTOR, IGC_OBJ_WEAK_VALUE_PAIR_VECTOR,
IGC_OBJ_WEAK_OR_PAIR_VECTOR.
(igc_alloc_pair_vector): New prototype.
* src/igc.c (obj_type_names, set_header, dflt_scan_obj, thread_ap):
Handle new tpes.
(struct igc_thread, create_ephemeron_ap, create_thread_aps)
(igc_thread_remove): Add allocation point for ephemeron pool.
(struct igc, make_pool_aeph, make_igc): Add ephemeron pool.
(as_igc_header, fix_pair_vector, decode_ptr, encode_ptr)
(increment_ndeleted, splat_pair, fix_weak_key_pair, fix_weak_value_pair)
(fix_weak_or_pair, fix_weak_and_pair, scan_pair_vector)
(fix_weak_key_pair_vector, fix_weak_value_pair_vector)
(fix_weak_or_pair_vector, fix_weak_and_pair_vector): New helpers.
(fix_hash_table, fix_weak_hash_table_strong_part)
(fix_weak_hash_table_weak_part): Adapt to hash_table_kv.
(igc_alloc_pair_vector): New function.
* src/fns.c (maybe_resize_hash_table): Call maybe_resize_hash_table.
(Fgethash): Add assertion for HASH_UNUSED_ENTRY_KEY.
(Fhash_table_count): Take deleted entries into account.
(hash_table_kv_init, hash_table_kv_create)
(hash_table_kv_resize, hash_table_kv_free): New helpers.
(hash_table_kv_ndeleted, hash_table_ndeleted)
(hash_table_count, reclaim_deleted_entries)
(maybe_reclaim_deleted_entries): New helpers.
(make_hash_table, copy_hash_table, hash_table_thaw, hash_table_rehash)
(allocate_weak_hash_table_parts, make_weak_hash_table)
(maybe_resize_weak_hash_table): Adapt to hash_table_kv.
* src/alloc.c (cleanup_vector): Adapt to hash_table_kv.
* src/pdumper.c (hash_table_contents, hash_table_freeze)
(dump_hash_table): Adapt to hash_table_kv.
(dump_hash_table_kv_slot, dump_hash_table_kv, dump_hash_table_kv_part):
New helpers.
* src/print.c (print_object): Use Fhash_table_count instead
of the h->count field.
* test/src/fns-tests.el (ft--check-entries): Check hash-table-count.
(ft-weak-fixnums2, ft--test-weak-fixnums2): New test.
(ft--test-ephemeron-table): Better check for hash-table-count.

The info returned from `garbage-collect` is really handy to
track the evolution of the heap size, but sadly it's available only
at the cost of running a full GC, which has two big downsides:
it's slow, it affects what we're measuring, and it can't be used
in `post-gc-hook`.
So, this patch makes it available without running the GC.

* src/alloc.c (Fgarbage_collect_heapsize): New function, extracted from
`Fgarbage_collect`.
(Fgarbage_collect): Use it.
(syms_of_alloc): defsubr it.

* doc/lispref/internals.texi (Garbage Collection): Extract
documentation for it from that of `garbage-collect`.

* src/alloc.c, src/gmalloc.c: Include <malloc.h> before <stdlib.h>.
This mimics include patterns elsewhere, and avoids a problem if
malloc.h declares realloc (i.e., rpl_realloc) early as extern,
whereas Gnulib stdlib.h declares it later as inline which means it
is extern inline, which clashes with gmalloc’s definition of
rpl_realloc when gmalloc.o is used.  Problem discovered when
building Emacs on Ubuntu 25.10 with "./configure CC='gcc -m32'
emacs_cv_struct_alignment=no gl_cv_header_working_stdalign_h=no".

Without this, bignum allocations in the pidigits don't properly trigger
GC.  This patch changes the peak memory usage for the pidigits benchmark
by a factor of 6.  The benchmark also begins to spend much more time in
GC, as it should be:

|        | max rss   | elapsed time |
|--------+-----------+--------------|
| before | 392472 KB | 6.7 s        |
| after  | 58512 KB  | 32.93 s      |

* src/bignum.h (init_gmp_memory_functions): Declare new function.
* src/alloc.c (init_gmp_memory_functions): Implement it.
(xmalloc_for_gmp): New helper.
(xrealloc_for_gmp, xfree_for_gmp): Moved here from bignum.c.
* src/bignum.c (init_bignum): Call init_gmp_memory_functions.

This reverts commit 1a339d54ea7e6a005973c7eb392155b2ce7065d5.

If FLAT_BIGNUMS is defined, Lisp_Bignums are a vector of GMP limbs
instead of a mpz_t (i.e. pointer to limb array).

The primary difficulty was the changed return type of the bignum_val
function.  The idiom "*bignum_val (foo)" was used all over the place.
For the flat representation, it seems impossible to define bignum_val
such that it returns a pointer.  I changed the return type to a struct,
but that made it necessary to change the idiom to "bignum_val (foo).z".

* src/bignum.h (FLAT_BIGNUMS): Define if HAVE_MPS.
(struct Lisp_Bignums): Define alternative representation.
(struct bignum_val): New helper struct.
(bignum_val): Change return type and define different version for flat
bignums.
(bignum_integer): Define a separate version for flat bignums.
(BIGNUM_VAL): New macro.
(init_gmp_memory_functions): New.  Define the prototype here for a
function that is implemented in alloc.c.
(mpz_set_integer): Update for changed xbignum_val.
* src/bignum.c (init_bignum): Call init_gmp_memory_functions.
(make_bignum_from_mpz): New helper.
(make_bignum_bits, make_bignum_str): Adapted for flat bignums.
(bignum_to_double, bignum_to_uintmax, bignum_bufsize, bignum_to_c_string)
(get_random_bignum): Adapt to changed bignum_val.
* src/alloc.c (xmalloc_for_gmp): New.
(xrealloc_for_gmp, xfree_for_gmp): Moved here from bignum.c.  Call
tally_consing.
(init_gmp_memory_functions): New.
(cleanup_vector): Adapt to flat bignums.
* src/data.c (Fnatnump, arithcompare, Fminus, integer_remainder)
(Flogcount, Fash, expt_integer, Fadd1, Fsub1, Flognot): Adapt to changed
bignum_val.
* src/emacs-module.c (module_extract_big_integer): Adapt to changed
bignum_val.
* src/floatfns.c (Fabs, Flogb): Adapt to changed bignum_val.
* src/fns.c (Frandom, Ftake, Fntake, Fnthcdr, Fmemql, Feql)
(internal_equal_1, value_cmp, sxhash_bignum): Adapt to changed
bignum_val.
* src/igc.c (finalize_bignum, finalize_vector, maybe_finalize): Adapt to
flat bignums.
* src/pdumper.c (dump_bignum): Define separate version for flat bignums.
(dump_cold_bignum, dump_do_dump_relocation): Adapt to changed
bignum_val.
* src/timefns.c (ztrillion, ticks_hz_to_timespec, ticks_hz_hz_ticks)
(lispint_arith): Adapt to changed bignum_val.