libctf: impose an ordering on conflicting types

When two types conflict and they are not types which can have forwards
(say, two arrays of different sizes with the same name in two different
TUs) the CTF deduplicator uses a popularity contest to decide what to
do: the type cited by the most other types ends up put into the shared
dict, while the others are relegated to per-CU child dicts.

This works well as long as one type *is* most popular -- but what if
there is a tie?  If several types have the same popularity count,
we end up picking the first we run across and promoting it, and
unfortunately since we are working over a dynhash in essentially
arbitrary order, this means we promote a random one.  So multiple
runs of ld with the same inputs can produce different outputs!
All the outputs are valid, but this is still undesirable.

Adjust things to use the same strategy used to sort types on the output:
when there is a tie, always put the type that appears in a CU that
appeared earlier on the link line (and if there is somehow still a tie,
which should be impossible, pick the type with the lowest type ID).

Add a testcase -- and since this emerged when trying out extern arrays,
check that those work as well (this requires a newer GCC, but since all
GCCs that can emit CTF at all are unreleased this is probably OK as
well).

Fix up one testcase that has slight type ordering changes as a result
of this change.

libctf/ChangeLog:

	* ctf-dedup.c (ctf_dedup_detect_name_ambiguity): Use
	cd_output_first_gid to break ties.

ld/ChangeLog:

	* testsuite/ld-ctf/array-conflicted-ordering.d: New test, using...
	* testsuite/ld-ctf/array-char-conflicting-1.c: ... this...
	* testsuite/ld-ctf/array-char-conflicting-2.c: ... and this.
	* testsuite/ld-ctf/array-extern.d: New test, using...
	* testsuite/ld-ctf/array-extern.c: ... this.
	* testsuite/ld-ctf/conflicting-typedefs.d: Adjust for ordering
	changes.

1 files changed, 20 insertions, 1 deletions

diff --git a/libctf/ctf-dedup.c b/libctf/ctf-dedup.c
index b2fb0a1..cddf437 100644
--- a/libctf/ctf-dedup.c
+++ b/libctf/ctf-dedup.c
@@ -1502,12 +1502,17 @@ ctf_dedup_detect_name_ambiguity (ctf_dict_t *fp, ctf_dict_t **inputs)
 	     the most-popular type on insertion, and we want conflicting structs
 	     et al to have all forwards left intact, so the user is notified
 	     that this type is conflicting.  TODO: improve this in future by
-	     setting such forwards non-root-visible.)  */
+	     setting such forwards non-root-visible.)
+
+	     If multiple distinct types are "most common", pick the one that
+	     appears first on the link line, and within that, the one with the
+	     lowest type ID.  (See sort_output_mapping.)  */
 
 	  const void *key;
 	  const void *count;
 	  const char *hval;
 	  long max_hcount = -1;
+	  void *max_gid = NULL;
 	  const char *max_hval = NULL;
 
 	  if (ctf_dynhash_elements (name_counts) <= 1)
@@ -1517,10 +1522,24 @@ ctf_dedup_detect_name_ambiguity (ctf_dict_t *fp, ctf_dict_t **inputs)
 	  while ((err = ctf_dynhash_cnext (name_counts, &j, &key, &count)) == 0)
 	    {
 	      hval = (const char *) key;
+
 	      if ((long int) (uintptr_t) count > max_hcount)
 		{
 		  max_hcount = (long int) (uintptr_t) count;
 		  max_hval = hval;
+		  max_gid = ctf_dynhash_lookup (d->cd_output_first_gid, hval);
+		}
+	      else if ((long int) (uintptr_t) count == max_hcount)
+		{
+		  void *gid = ctf_dynhash_lookup (d->cd_output_first_gid, hval);
+
+		  if (CTF_DEDUP_GID_TO_INPUT(gid) < CTF_DEDUP_GID_TO_INPUT(max_gid)
+		      || (CTF_DEDUP_GID_TO_INPUT(gid) == CTF_DEDUP_GID_TO_INPUT(max_gid)
+			  && CTF_DEDUP_GID_TO_TYPE(gid) < CTF_DEDUP_GID_TO_TYPE(max_gid)))
+		    {
+		      max_hval = hval;
+		      max_gid = ctf_dynhash_lookup (d->cd_output_first_gid, hval);
+		    }
 		}
 	    }
 	  if (err != ECTF_NEXT_END)