tree 3418ffefbfa35c3683d5279d5be87fedc0d78d17
parent 0c5f03a9d5ed35731742df2c98cc5ec6aa738828
author Nick Alcock <nick.alcock@oracle.com> 1718131893 +0100
committer Nick Alcock <nick.alcock@oracle.com> 1718713231 +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
 ZwAAAANnaXQAAAAAAAAABnNoYTUxMgAAAZQAAAAMcnNhLXNoYTItNTEyAAABgJ0IKxCs32
 DJjYWd3Qol90i+WuFOyEOUxL5Z8nqd4XlzIE1bzjGnA7ceAIQOMZ+GpmMCIOe42oLvk3/T
 lBk+aWoisgoyl8zytuwXPH7EinK57Yr5w0I1/Ymm4pZNc45yuMpQQLgz/Zw2oYjq/hPCOS
 4LaDAoJw1rgUVVMY2dXx7Mf+2+fswW6ErOs+4kt/jNQ/rBAi239JtdLjJBKFWz7C+SfJBc
 34qrvG2KajxWf6ImuCYwWHwFaPibdtzXVpsVw4aHQNNGUqHeiaMg0Fft1W+sRTY8NwtJi9
 mlsKiWvhu3MKCzU3wYmNiOOyYxy7Ag7+LuY+/E7w/Go/RahiLrV+AmQ7I9zpB9zZGe58+O
 HGKW5mwYYQZDbbEUBCbI1e2LAA8nkIIT9kvEkkDNpPi6CXz6kIOvOeuUyuiXBtVlTcBop0
 H7nvZjv0QmKk2cATNB512U59o6twy8M9iSfSgzYlqC/XPatMXGUYwDvb4kI40Ve4/ch/A+
 d9e6OAJV2b/6hA==
 -----END SSH SIGNATURE-----

libctf: dedup: enums with overlapping enumerators are conflicting

The CTF deduplicator was not considering enumerators inside enum types to be
things that caused type conflicts, so if the following two TUs were linked
together, you would end up with the following in the resulting dict:

1.c:
enum foo { A, B };

2.c:
enum bar { A, B };

linked:

enum foo { A, B };
enum bar { A, B };

This does work -- but it's not something that's valid C, and the general
point of the shared dict is that it is something that you could potentially
get from any valid C TU.

So consider such types to be conflicting, but obviously don't consider
actually identical enums to be conflicting, even though they too have (all)
their identifiers in common.  This involves surprisingly little code. The
deduplicator detects conflicting types by counting types in a hash table of
hash tables:

decorated identifier -> (type hash -> count)

where the COUNT is the number of times a given hash has been observed: any
name with more than one hash associated with it is considered conflicting
(the count is used to identify the most common such name for promotion to
the shared dict).

Before now, those identifiers were all the identifiers of types (possibly
decorated with their namespace on the front for enumerator identifiers), but
we can equally well put *enumeration constant names* in there, undecorated
like the identifiers of types in the global namespace, with the type hash
being the hash of each enum containing that enumerator.  The existing
conflicting-type-detection code will then accurately identify distinct enums
with enumeration constants in common.  The enum that contains the most
commonly-appearing enumerators will be promoted to the shared dict.

libctf/
	* ctf-impl.h (ctf_dedup_t) <cd_name_counts>: Extend comment.
	* ctf-dedup.c (ctf_dedup_count_name): New, split out of...
	(ctf_dedup_populate_mappings): ... here.  Call it for all
	* enumeration constants in an enum as well as types.

ld/
	* testsuite/ld-ctf/enum-3.c: New test CTF.
	* testsuite/ld-ctf/enum-4.c: Likewise.
	* testsuite/ld-ctf/overlapping-enums.d: New test.
	* testsuite/ld-ctf/overlapping-enums-2.d: Likewise.