tree 492f11765af1f4d41f3f8f82d787ba8ea34339c1
parent 68720e03f58f4c4565f5d8724742acc5951210fa
author Nick Alcock <nick.alcock@oracle.com> 1720784642 +0100
committer Nick Alcock <nick.alcock@oracle.com> 1722456124 +0100
gpgsig -----BEGIN SSH SIGNATURE-----
 U1NIU0lHAAAAAQAAAZcAAAAHc3NoLXJzYQAAAAMBAAEAAAGBAKdXbpSWQhTP/aUxya43ib
 VtyXn3Hk+y9hCYV9LAooJ/+GmyHf811M1BxhHcZ1s81pNnWhDZKEsUPVp2w/aOOJnuYHVj
 z3/YqeqyrdYhuPHwwF/GxoE4cINyZZvUCBvQu1mX5xAjGKPiJUmXcONuleaiSdPAh/Ji2k
 M2l+8A3zAOIoTYdHxDRNjlwpPTV/QLhqq0sQosQM2ev40IwXO80f7cots5LE3b5gXWsZZ5
 GHYLFpWjn7gRsoFSY0pgRYZY+/BPtVujEp2ahnXCD79TIbQF7Moii0oz/xNXfvQ07YUPex
 ZVzaREX5fhU96/rnPwGcyVGADLaypISlLMOJ73rjiIN+SaJHtmVBKIs3rDBKd0uAe1GIdz
 ZKYW30gTDw2Ac/qoCoN7WV7KTwwktB/3gcjK4XPVagLPG4cmPigFD1l/qxB9uCHbJFoklj
 tYiCCVgz3xGoVoe+13+uHieDQtyiKSnFRMTqEx7Z30S+UvNLte3j1AXrwLwSNsSDbRvOnk
 ZwAAAANnaXQAAAAAAAAABnNoYTUxMgAAAZQAAAAMcnNhLXNoYTItNTEyAAABgDjI9SvQfb
 icYQ9lwFUtTsSfHdiZe6CfDM8MoEiBk+4uXuRH8j89QQvHw1tC0FxjfD8vGntY2P/uSVJi
 tPy0JnVjOpnhID15RRLKj8ZUNRKu3SSFxBs7O0Yg7MU9TP1dESMYlG0HjlICbK7dHRekZ+
 +8pCbYgsthMmWl3+r5lsiRldxaxBBQLkdGGigKc6crI+oE9QXsgGuZ4DvQFWp4R48mZp+R
 KiB45L3zVAu7UK7Hlaz4h6IXp5rhMvLrT7YgOaEdCH/W2ucDa5RFu8H2+zcaIJG0z8xYB/
 GJS9jt1haIe/Z/z0M+nbnLKZwVnQx2HeoZj8pY1oEncXm5QlQefEkODN1MQ2NiwDk3BdXe
 xR9zT5ytYydH0I07IYtiKb1/ZhnRPXfZlSf+G1jd0Qx4qFB1pA6DlKIbB3TfF2BKS7ykqt
 Xwe+rqfZwzWSgabEWIilm5qvA5rVHubIBu5DFk8oUq41WVkydCw73cjEoMNJdKbw25Geap
 iAOW6mAjFspGiw==
 -----END SSH SIGNATURE-----

libctf, string: split the movable refs out of the ref list

In commit 149ce5c263616e65 we introduced the concept of "movable" refs,
which are refs that can be moved in batches, to let us maintain valid ref
lists even when adding refs to blocks of memory that can be realloced (which
is any type containing a vlen which can expand, like names contained within
enum or struct members).  Movable refs need a backpointer to the movable
refs dynhash for this dict; since non-movable refs are very common, we tried
to save memory by having a slightly bigger struct for moveable refs with a
backpointer in it, and casting appropriately, indicating which sort of ref
we were dealing with via a flag on the atom.

Unfortunately this doesn't work reliably, because you can perfectly well
have a string ("foo", say) which has both non-movable refs (say, an external
symbol and a variable name) and movable refs (say, a structure member name)
to the same atom.  Indicate which struct we're dealing with with an atom
flag and suddenly you're casting a ctf_str_atom_ref to a
ctf_str_atom_ref_movable (which is bigger) and dereferencing random memory
off the end of it and interpreting it as a backpointer to the movable refs
dynhash.  This is unlikely to work well.

So bite the bullet and split refs into two separate lists, one for movable
refs, one for immovable refs. It means some annoying code duplication, but
there's not very much of it, and it means we can keep the movable refs
hashtab (which in turn means we don't have to do linear searches to find all
relevant refs when moving refs, which in turn means that
structure/union/enum member additions remain amortized O(n) time, not
O(n^2).

Callers can now purge movable and non-movable refs independently of each
other.  We don't use this yet, but a use is coming.

libctf/
	* ctf-impl.h (CTF_STR_ATOM_MOVABLE): Delete.
        (struct ctf_str_atom) [csa_movable_refs]: New.
	(struct ctf_dict): Adjust comment.
	(ctf_str_purge_refs): Add MOVABLE arg.
	* ctf-string.c (ctf_str_purge_movable_atom_refs): Split out of...
        (ctf_str_purge_atom_refs): ... this.
	(ctf_str_free_atom): Call it.
	(ctf_str_purge_one_atom_refs): Likewise.
	(aref_create): Adjust accordingly.
	(ctf_str_move_refs): Likewise.
	(ctf_str_remove_ref): Remove movable refs too, including
	deleting the ref from ctf_str_movable_refs.
	(ctf_str_purge_refs): Add MOVABLE arg.
	(ctf_str_update_refs): Update movable refs.
	(ctf_str_write_strtab): Check, and purge, movable refs.