c++: mangling cNTTP object w/ implicit non-trailing zeros [PR121231]

Here the results of A::make(0, 0, 1), (0, 1, 0) and (1, 0, 0) are each
represented as a single-element CONSTRUCTOR with CONSTRUCTOR_NO_CLEARING
cleared, and when used as as a class NTTP argument we end up mangling them
all as A{1}, i.e. eliding both the implicit initial and trailing zeros.
Mangling them all the same seems clearly wrong since they're logically
different values.

It turns out the mangling also omits intermediate zeros, e.g.
A::make(1, 0, 1) is mangled as A{1, 1}, the same as A::make(1, 1, 0).

It seems we can't omit both trailing and non-trailing implicit zeros
without introducing mangling ambiguities.  This patch makes us include
non-trailing zeros in these manglings (while continuing to omit trailing
zeros).

This also manifests as a wrong-code bug where the specializations table
would conflate different specializations that are in terms of different
class NTTP arguments, since the identity of such arguments is tied to
their mangling.

	PR c++/121231
	PR c++/119688
	PR c++/94511

gcc/ChangeLog:

	* common.opt: Document additional ABI version 21 change.
	* doc/invoke.texi: Likewise.

gcc/cp/ChangeLog:

	* mangle.cc (write_expression): Write out implicit non-trailing
	zeroes of a CONSTRUCTOR when the ABI version is at least 21.

gcc/testsuite/ChangeLog:

	* g++.dg/abi/mangle82.C: New test.
	* g++.dg/cpp2a/nontype-class73.C: New test.

Reviewed-by: Jason Merrill <jason@redhat.com>

1 files changed, 51 insertions, 0 deletions

diff --git a/gcc/cp/mangle.cc b/gcc/cp/mangle.cc
index 13d5ded..fd69099 100644
--- a/gcc/cp/mangle.cc
+++ b/gcc/cp/mangle.cc
@@ -3745,11 +3745,59 @@ write_expression (tree expr)
 		      || !zero_init_expr_p (ce->value))
 		    last_nonzero = i;
 
+	      tree prev_field = NULL_TREE;
 	      if (undigested || last_nonzero != UINT_MAX)
 		for (HOST_WIDE_INT i = 0; vec_safe_iterate (elts, i, &ce); ++i)
 		  {
 		    if (i > last_nonzero)
 		      break;
+		    if (!undigested && !CONSTRUCTOR_NO_CLEARING (expr)
+			&& (TREE_CODE (etype) == RECORD_TYPE
+			    || TREE_CODE (etype) == ARRAY_TYPE))
+		      {
+			/* Write out any implicit non-trailing zeros
+			   (which we neglected to do before v21).  */
+			if (TREE_CODE (etype) == RECORD_TYPE)
+			  {
+			    tree field;
+			    if (i == 0)
+			      field = first_field (etype);
+			    else
+			      field = DECL_CHAIN (prev_field);
+			    for (;;)
+			      {
+				field = next_subobject_field (field);
+				if (field == ce->index)
+				  break;
+				if (abi_check (21))
+				  write_expression (build_zero_cst
+						    (TREE_TYPE (field)));
+				field = DECL_CHAIN (field);
+			      }
+			  }
+			else if (TREE_CODE (etype) == ARRAY_TYPE)
+			  {
+			    unsigned HOST_WIDE_INT j;
+			    if (i == 0)
+			      j = 0;
+			    else
+			      j = 1 + tree_to_uhwi (prev_field);
+			    unsigned HOST_WIDE_INT k;
+			    if (TREE_CODE (ce->index) == RANGE_EXPR)
+			      k = tree_to_uhwi (TREE_OPERAND (ce->index, 0));
+			    else
+			      k = tree_to_uhwi (ce->index);
+			    tree zero = NULL_TREE;
+			    for (; j < k; ++j)
+			      if (abi_check (21))
+				{
+				  if (!zero)
+				    zero = build_zero_cst (TREE_TYPE (etype));
+				  write_expression (zero);
+				}
+			  }
+		      }
+
 		    if (!undigested && TREE_CODE (etype) == UNION_TYPE)
 		      {
 			/* Express the active member as a designator.  */
@@ -3794,6 +3842,9 @@ write_expression (tree expr)
 		    else
 		      for (unsigned j = 0; j < reps; ++j)
 			write_expression (ce->value);
+		    prev_field = ce->index;
+		    if (prev_field && TREE_CODE (prev_field) == RANGE_EXPR)
+		      prev_field = TREE_OPERAND (prev_field, 1);
 		  }
 	    }
 	  else