This is the mail archive of the gcc-patches@gcc.gnu.org mailing list for the GCC project.


Index Nav: [Date Index] [Subject Index] [Author Index] [Thread Index]
Message Nav: [Date Prev] [Date Next] [Thread Prev] [Thread Next]
Other format: [Raw text]

Re: C++ PATCH for c++/57891, narrowing conversions in non-type template arguments


On Tue, Jul 03, 2018 at 04:27:33PM -0400, Jason Merrill wrote:
> On Tue, Jul 3, 2018 at 3:41 PM, Jason Merrill <jason@redhat.com> wrote:
> > On Tue, Jul 3, 2018 at 2:58 PM, Marek Polacek <polacek@redhat.com> wrote:
> >> On Tue, Jul 03, 2018 at 12:40:51PM -0400, Jason Merrill wrote:
> >>> On Fri, Jun 29, 2018 at 3:58 PM, Marek Polacek <polacek@redhat.com> wrote:
> >>> > On Wed, Jun 27, 2018 at 07:35:15PM -0400, Jason Merrill wrote:
> >>> >> On Wed, Jun 27, 2018 at 12:53 PM, Marek Polacek <polacek@redhat.com> wrote:
> >>> >> > This PR complains about us accepting invalid code like
> >>> >> >
> >>> >> >   template<unsigned int> struct A {};
> >>> >> >   A<-1> a;
> >>> >> >
> >>> >> > Where we should detect the narrowing: [temp.arg.nontype] says
> >>> >> > "A template-argument for a non-type template-parameter shall be a converted
> >>> >> > constant expression ([expr.const]) of the type of the template-parameter."
> >>> >> > and a converted constant expression can contain only
> >>> >> > - integral conversions other than narrowing conversions,
> >>> >> > - [...]."
> >>> >> > It spurred e.g.
> >>> >> > <https://stackoverflow.com/questions/28184888/how-implicit-conversion-works-for-non-type-template-parameters>
> >>> >> > and has >=3 dups so it has some visibility.
> >>> >> >
> >>> >> > I think build_converted_constant_expr needs to set check_narrowing.
> >>> >> > check_narrowing also always mentions that it's in { } but that is no longer
> >>> >> > true; in the future it will also apply to <=>.  We'd probably have to add a new
> >>> >> > flag to struct conversion if wanted to distinguish between these.
> >>> >> >
> >>> >> > This does not yet fix detecting narrowing in function templates (78244).
> >>> >> >
> >>> >> > Bootstrapped/regtested on x86_64-linux, ok for trunk?
> >>> >> >
> >>> >> > 2018-06-27  Marek Polacek  <polacek@redhat.com>
> >>> >> >
> >>> >> >         PR c++/57891
> >>> >> >         * call.c (build_converted_constant_expr): Set check_narrowing.
> >>> >> >         * decl.c (compute_array_index_type): Add warning sentinel.  Use
> >>> >> >         input_location.
> >>> >> >         * pt.c (convert_nontype_argument): Return NULL_TREE if any errors
> >>> >> >         were reported.
> >>> >> >         * typeck2.c (check_narrowing): Don't mention { } in diagnostic.
> >>> >> >
> >>> >> >         * g++.dg/cpp0x/Wnarrowing6.C: New test.
> >>> >> >         * g++.dg/cpp0x/Wnarrowing7.C: New test.
> >>> >> >         * g++.dg/cpp0x/Wnarrowing8.C: New test.
> >>> >> >         * g++.dg/cpp0x/constexpr-data2.C: Add dg-error.
> >>> >> >         * g++.dg/init/new43.C: Adjust dg-error.
> >>> >> >         * g++.dg/other/fold1.C: Likewise.
> >>> >> >         * g++.dg/parse/array-size2.C: Likewise.
> >>> >> >         * g++.dg/other/vrp1.C: Add dg-error.
> >>> >> >         * g++.dg/template/char1.C: Likewise.
> >>> >> >         * g++.dg/ext/builtin12.C: Likewise.
> >>> >> >         * g++.dg/template/dependent-name3.C: Adjust dg-error.
> >>> >> >
> >>> >> > diff --git gcc/cp/call.c gcc/cp/call.c
> >>> >> > index 209c1fd2f0e..956c7b149dc 100644
> >>> >> > --- gcc/cp/call.c
> >>> >> > +++ gcc/cp/call.c
> >>> >> > @@ -4152,7 +4152,10 @@ build_converted_constant_expr (tree type, tree expr, tsubst_flags_t complain)
> >>> >> >      }
> >>> >> >
> >>> >> >    if (conv)
> >>> >> > -    expr = convert_like (conv, expr, complain);
> >>> >> > +    {
> >>> >> > +      conv->check_narrowing = !processing_template_decl;
> >>> >>
> >>> >> Why !processing_template_decl?  This needs a comment.
> >>> >
> >>> > Otherwise we'd warn for e.g.
> >>> >
> >>> > template<int N> struct S { char a[N]; };
> >>> > S<1> s;
> >>> >
> >>> > where compute_array_index_type will try to convert the size of the array (which
> >>> > is a template_parm_index of type int when parsing the template) to size_type.
> >>> > So I guess I can say that we need to wait for instantiation?
> >>>
> >>> We certainly shouldn't give a narrowing diagnostic about a
> >>> value-dependent expression.  It probably makes sense to check that at
> >>> the top of check_narrowing, with all the other early exit conditions.
> >>> But if we do know the constant value in the template, it's good to
> >>> complain then rather than wait for instantiation.
> >>
> >> Makes sense; how about this then?  (Regtest/bootstrap running.)
> >>
> >> 2018-07-03  Marek Polacek  <polacek@redhat.com>
> >>
> >>         PR c++/57891
> >>         * call.c (build_converted_constant_expr): Set check_narrowing.
> >>         * decl.c (compute_array_index_type): Add warning sentinel.  Use
> >>         input_location.
> >>         * pt.c (convert_nontype_argument): Return NULL_TREE if any errors
> >>         were reported.
> >>         * typeck2.c (check_narrowing): Don't warn for instantiation-dependent
> >>         expressions or non-constants in a template.  Don't mention { } in
> >>         diagnostic.
> >>
> >>         * g++.dg/cpp0x/Wnarrowing6.C: New test.
> >>         * g++.dg/cpp0x/Wnarrowing7.C: New test.
> >>         * g++.dg/cpp0x/Wnarrowing8.C: New test.
> >>         * g++.dg/cpp0x/Wnarrowing9.C: New test.
> >>         * g++.dg/cpp0x/Wnarrowing10.C: New test.
> >>         * g++.dg/cpp0x/constexpr-data2.C: Add dg-error.
> >>         * g++.dg/init/new43.C: Adjust dg-error.
> >>         * g++.dg/other/fold1.C: Likewise.
> >>         * g++.dg/parse/array-size2.C: Likewise.
> >>         * g++.dg/other/vrp1.C: Add dg-error.
> >>         * g++.dg/template/char1.C: Likewise.
> >>         * g++.dg/ext/builtin12.C: Likewise.
> >>         * g++.dg/template/dependent-name3.C: Adjust dg-error.
> >>
> >> diff --git gcc/cp/call.c gcc/cp/call.c
> >> index 209c1fd2f0e..4fb0fa8774b 100644
> >> --- gcc/cp/call.c
> >> +++ gcc/cp/call.c
> >> @@ -4152,7 +4152,10 @@ build_converted_constant_expr (tree type, tree expr, tsubst_flags_t complain)
> >>      }
> >>
> >>    if (conv)
> >> -    expr = convert_like (conv, expr, complain);
> >> +    {
> >> +      conv->check_narrowing = true;
> >> +      expr = convert_like (conv, expr, complain);
> >> +    }
> >>    else
> >>      expr = error_mark_node;
> >>
> >> diff --git gcc/cp/decl.c gcc/cp/decl.c
> >> index c04b9b7d457..8da63fa2aaa 100644
> >> --- gcc/cp/decl.c
> >> +++ gcc/cp/decl.c
> >> @@ -9508,6 +9508,8 @@ compute_array_index_type (tree name, tree size, tsubst_flags_t complain)
> >>        else
> >>         {
> >>           size = instantiate_non_dependent_expr_sfinae (size, complain);
> >> +         /* Don't warn about narrowing for VLAs.  */
> >> +         warning_sentinel s (warn_narrowing, !TREE_CONSTANT (osize));
> >>           size = build_converted_constant_expr (size_type_node, size, complain);
> >
> > Hmm, perhaps the underlying issue is that we only want
> > build_converted_constant_expr to check for narrowing of constant
> > values; if the value isn't constant, it isn't any kind of constant
> > expression.  So perhaps the checking needs to happen as part of
> > constexpr evaluation.
> 
> On the other hand, check_narrowing itself forces constexpr evaluation,
> so this could be handled all in the conversion code; we just need to
> tell check_narrowing to allow non-constant values in that case.

OK -- see the patch below.  Now, I'm not crazy about adding another bit
to struct conversion, but reusing any of the other bits didn't seem
safe/possible.  Maybe it'll come in handy when dealing with this problem
for function templates.
 
> >> @@ -6669,9 +6669,12 @@ convert_nontype_argument (tree type, tree expr, tsubst_flags_t complain)
> >>           /* C++17: A template-argument for a non-type template-parameter shall
> >>              be a converted constant expression (8.20) of the type of the
> >>              template-parameter.  */
> >> +         int errs = errorcount;
> >>           expr = build_converted_constant_expr (type, expr, complain);
> >>           if (expr == error_mark_node)
> >> -           return error_mark_node;
> >> +           /* Make sure we return NULL_TREE only if we have really issued
> >> +              an error, as described above.  */
> >> +           return errorcount > errs ? NULL_TREE : error_mark_node;
> >
> > Is this still needed?
> 
> Earlier you wrote,
> 
> > Checking complain doesn't work because that doesn't
> > say if we have really issued an error.  If we have not, and we return
> > NULL_TREE anyway, we hit this assert:
> >  8517       gcc_assert (!(complain & tf_error) || seen_error ());
> 
> If (complain & tf_error), we shouldn't see error_mark_node without an
> error having been issued.  Why is build_converted_constant_expr
> returning error_mark_node without giving an error when (complain &
> tf_error)?

This can happen on invalid code; e.g. tests nontype13.C and crash87.C.
What happens there is that we're trying to convert a METHOD_TYPE to bool,
which doesn't work: in standard_conversion we go into the 
    else if (tcode == BOOLEAN_TYPE)
block, which returns NULL, implicit_conversion also then returns NULL, yet
no error has been issued.

> >> +      /* If we're in a template and we know the constant value, we can
> >> +        warn.  Otherwise wait for instantiation.  */
> >> +      || (processing_template_decl && !TREE_CONSTANT (init)))
> >
> > I don't think we want this condition.  If the value is non-constant
> > but also not dependent, it'll never be constant, so we can go ahead
> > and complain.

(This to be investigated later.)

Bootstrapped/regtested on x86_64-linux, ok for trunk?

2018-07-23  Marek Polacek  <polacek@redhat.com>

	PR c++/57891
	* call.c (struct conversion): Add check_narrowing_const_only.
	(build_converted_constant_expr): Set check_narrowing and
	check_narrowing_const_only.
	(convert_like_real): Pass it to check_narrowing.
	* cp-tree.h (check_narrowing): Add a default parameter.
	* decl.c (compute_array_index_type): Use input_location.
	* pt.c (convert_nontype_argument): Return NULL_TREE if any errors
	were reported.
	* typeck2.c (check_narrowing): Don't warn for instantiation-dependent
	expressions or non-constants in a template.  Don't mention { } in
	diagnostic.  Only check narrowing for constants if CONST_ONLY.

	* g++.dg/cpp0x/Wnarrowing6.C: New test.
	* g++.dg/cpp0x/Wnarrowing7.C: New test.
	* g++.dg/cpp0x/Wnarrowing8.C: New test.
	* g++.dg/cpp0x/Wnarrowing9.C: New test.
	* g++.dg/cpp0x/Wnarrowing10.C: New test.
	* g++.dg/cpp0x/constexpr-data2.C: Add dg-error.
	* g++.dg/init/new43.C: Adjust dg-error.
	* g++.dg/other/fold1.C: Likewise.
	* g++.dg/parse/array-size2.C: Likewise.
	* g++.dg/template/dependent-name3.C: Likewise.
	* g++.dg/other/vrp1.C: Add dg-error.
	* g++.dg/template/char1.C: Likewise.

diff --git gcc/cp/call.c gcc/cp/call.c
index 209c1fd2f0e..e612be91070 100644
--- gcc/cp/call.c
+++ gcc/cp/call.c
@@ -107,6 +107,9 @@ struct conversion {
      binding a reference directly or decaying to a pointer.  */
   BOOL_BITFIELD rvaluedness_matches_p: 1;
   BOOL_BITFIELD check_narrowing: 1;
+  /* Whether check_narrowing should only check TREE_CONSTANTs; used
+     in build_converted_constant_expr.  */
+  BOOL_BITFIELD check_narrowing_const_only: 1;
   /* The type of the expression resulting from the conversion.  */
   tree type;
   union {
@@ -4152,7 +4155,11 @@ build_converted_constant_expr (tree type, tree expr, tsubst_flags_t complain)
     }
 
   if (conv)
-    expr = convert_like (conv, expr, complain);
+    {
+      conv->check_narrowing = true;
+      conv->check_narrowing_const_only = true;
+      expr = convert_like (conv, expr, complain);
+    }
   else
     expr = error_mark_node;
 
@@ -7142,7 +7149,8 @@ convert_like_real (conversion *convs, tree expr, tree fn, int argnum,
     }
 
   if (convs->check_narrowing
-      && !check_narrowing (totype, expr, complain))
+      && !check_narrowing (totype, expr, complain,
+			   convs->check_narrowing_const_only))
     return error_mark_node;
 
   warning_sentinel w (warn_zero_as_null_pointer_constant);
diff --git gcc/cp/cp-tree.h gcc/cp/cp-tree.h
index 0fac7e9892f..656ddbb2150 100644
--- gcc/cp/cp-tree.h
+++ gcc/cp/cp-tree.h
@@ -7354,7 +7354,8 @@ extern int abstract_virtuals_error_sfinae	(abstract_class_use, tree, tsubst_flag
 
 extern tree store_init_value			(tree, tree, vec<tree, va_gc>**, int);
 extern tree split_nonconstant_init		(tree, tree);
-extern bool check_narrowing			(tree, tree, tsubst_flags_t);
+extern bool check_narrowing			(tree, tree, tsubst_flags_t,
+						 bool = false);
 extern tree digest_init				(tree, tree, tsubst_flags_t);
 extern tree digest_init_flags			(tree, tree, int, tsubst_flags_t);
 extern tree digest_nsdmi_init		        (tree, tree, tsubst_flags_t);
diff --git gcc/cp/decl.c gcc/cp/decl.c
index 3c1e2ef3698..265acf8984e 100644
--- gcc/cp/decl.c
+++ gcc/cp/decl.c
@@ -9581,7 +9581,7 @@ compute_array_index_type (tree name, tree size, tsubst_flags_t complain)
     {
       tree folded = cp_fully_fold (size);
       if (TREE_CODE (folded) == INTEGER_CST)
-	pedwarn (location_of (size), OPT_Wpedantic,
+	pedwarn (input_location, OPT_Wpedantic,
 		 "size of array is not an integral constant-expression");
       /* Use the folded result for VLAs, too; it will have resolved
 	 SIZEOF_EXPR.  */
diff --git gcc/cp/pt.c gcc/cp/pt.c
index 27805040ddb..1c70ec6b182 100644
--- gcc/cp/pt.c
+++ gcc/cp/pt.c
@@ -6680,9 +6680,12 @@ convert_nontype_argument (tree type, tree expr, tsubst_flags_t complain)
 	  /* C++17: A template-argument for a non-type template-parameter shall
 	     be a converted constant expression (8.20) of the type of the
 	     template-parameter.  */
+	  int errs = errorcount;
 	  expr = build_converted_constant_expr (type, expr, complain);
 	  if (expr == error_mark_node)
-	    return error_mark_node;
+	    /* Make sure we return NULL_TREE only if we have really issued
+	       an error, as described above.  */
+	    return errorcount > errs ? NULL_TREE : error_mark_node;
 	  expr = maybe_constant_value (expr);
 	  expr = convert_from_reference (expr);
 	}
diff --git gcc/cp/typeck2.c gcc/cp/typeck2.c
index 91aa5a62856..ba9c49b307e 100644
--- gcc/cp/typeck2.c
+++ gcc/cp/typeck2.c
@@ -875,10 +875,12 @@ store_init_value (tree decl, tree init, vec<tree, va_gc>** cleanups, int flags)
 }
 
 
-/* Give diagnostic about narrowing conversions within { }.  */
+/* Give diagnostic about narrowing conversions within { }, or as part of
+   a converted constant expression.  If CONST_ONLY, only check
+   constants.  */
 
 bool
-check_narrowing (tree type, tree init, tsubst_flags_t complain)
+check_narrowing (tree type, tree init, tsubst_flags_t complain, bool const_only)
 {
   tree ftype = unlowered_expr_type (init);
   bool ok = true;
@@ -886,7 +888,12 @@ check_narrowing (tree type, tree init, tsubst_flags_t complain)
 
   if (((!warn_narrowing || !(complain & tf_warning))
        && cxx_dialect == cxx98)
-      || !ARITHMETIC_TYPE_P (type))
+      || !ARITHMETIC_TYPE_P (type)
+      /* Don't emit bogus warnings with e.g. value-dependent trees.  */
+      || instantiation_dependent_expression_p (init)
+      /* If we're in a template and we know the constant value, we can
+	 warn.  Otherwise wait for instantiation.  */
+      || (processing_template_decl && !TREE_CONSTANT (init)))
     return ok;
 
   if (BRACE_ENCLOSED_INITIALIZER_P (init)
@@ -904,6 +911,10 @@ check_narrowing (tree type, tree init, tsubst_flags_t complain)
 
   init = fold_non_dependent_expr (init, complain);
 
+  /* If we were asked to only check constants, return early.  */
+  if (const_only && !TREE_CONSTANT (init))
+    return ok;
+
   if (TREE_CODE (type) == INTEGER_TYPE
       && TREE_CODE (ftype) == REAL_TYPE)
     ok = false;
@@ -967,7 +978,7 @@ check_narrowing (tree type, tree init, tsubst_flags_t complain)
 	{
 	  if (complain & tf_warning)
 	    warning_at (loc, OPT_Wnarrowing, "narrowing conversion of %qE "
-			"from %qH to %qI inside { } is ill-formed in C++11",
+			"from %qH to %qI is ill-formed in C++11",
 			init, ftype, type);
 	  ok = true;
 	}
@@ -977,8 +988,7 @@ check_narrowing (tree type, tree init, tsubst_flags_t complain)
 	    {
 	      if ((!almost_ok || pedantic)
 		  && pedwarn (loc, OPT_Wnarrowing,
-			      "narrowing conversion of %qE "
-			      "from %qH to %qI inside { }",
+			      "narrowing conversion of %qE from %qH to %qI",
 			      init, ftype, type)
 		  && almost_ok)
 		inform (loc, " the expression has a constant value but is not "
@@ -991,8 +1001,8 @@ check_narrowing (tree type, tree init, tsubst_flags_t complain)
 	  int savederrorcount = errorcount;
 	  global_dc->pedantic_errors = 1;
 	  pedwarn (loc, OPT_Wnarrowing,
-		   "narrowing conversion of %qE from %qH to %qI "
-		   "inside { }", init, ftype, type);
+		   "narrowing conversion of %qE from %qH to %qI ",
+		   init, ftype, type);
 	  if (errorcount == savederrorcount)
 	    ok = true;
 	  global_dc->pedantic_errors = flag_pedantic_errors;
diff --git gcc/testsuite/g++.dg/cpp0x/constexpr-data2.C gcc/testsuite/g++.dg/cpp0x/constexpr-data2.C
index 898102167de..dee5ed82301 100644
--- gcc/testsuite/g++.dg/cpp0x/constexpr-data2.C
+++ gcc/testsuite/g++.dg/cpp0x/constexpr-data2.C
@@ -43,4 +43,4 @@ extern template struct A3<int, 510>;
 
 // Use.
 A3<int, 1111> a31;
-A3<char, 9999> a32;		// { dg-warning "overflow" }
+A3<char, 9999> a32;		// { dg-error "narrowing conversion" }
diff --git gcc/testsuite/g++.dg/init/new43.C gcc/testsuite/g++.dg/init/new43.C
index 9b0866720fe..495c2bb01f0 100644
--- gcc/testsuite/g++.dg/init/new43.C
+++ gcc/testsuite/g++.dg/init/new43.C
@@ -31,35 +31,35 @@ void test_literal ()
 
     // Verify integer literal.
     p = new char [-1];           // { dg-error "size of array is negative" }
-    p = new char [2][-3];        // { dg-error "size of array is negative" }
+    p = new char [2][-3];        // { dg-error "size of array is negative|narrowing conversion" }
     p = new char [-4][5];        // { dg-error "size of array is negative" }
-    p = new char [-6][-7];       // { dg-error "size of array is negative" }
+    p = new char [-6][-7];       // { dg-error "size of array is negative|narrowing conversion" }
 
     p = new (p) char [-1];       // { dg-error "size of array is negative" }
-    p = new (p) char [2][-3];    // { dg-error "size of array is negative" }
+    p = new (p) char [2][-3];    // { dg-error "size of array is negative|narrowing conversion" }
     p = new (p) char [-4][5];    // { dg-error "size of array is negative" }
-    p = new (p) char [-6][-7];   // { dg-error "size of array is negative" }
+    p = new (p) char [-6][-7];   // { dg-error "size of array is negative|narrowing conversion" }
 
     p = new (p) A [-1];          // { dg-error "size of array is negative" }
-    p = new (p) A [2][-3];       // { dg-error "size of array is negative" }
+    p = new (p) A [2][-3];       // { dg-error "size of array is negative|narrowing conversion" }
     p = new (p) A [-4][5];       // { dg-error "size of array is negative" }
-    p = new (p) A [-6][-7];      // { dg-error "size of array is negative" }
+    p = new (p) A [-6][-7];      // { dg-error "size of array is negative|narrowing conversion" }
 
     p = new (p) B [-1];          // { dg-error "size of array is negative" }
-    p = new (p) B [2][-3];       // { dg-error "size of array is negative" }
+    p = new (p) B [2][-3];       // { dg-error "size of array is negative|narrowing conversion" }
     p = new (p) B [-4][5];       // { dg-error "size of array is negative" }
-    p = new (p) B [-6][-7];      // { dg-error "size of array is negative" }
+    p = new (p) B [-6][-7];      // { dg-error "size of array is negative|narrowing conversion" }
 
     p = new (&b) B [-1];          // { dg-error "size of array is negative" }
-    p = new (&b) B [2][-3];       // { dg-error "size of array is negative" }
+    p = new (&b) B [2][-3];       // { dg-error "size of array is negative|narrowing conversion" }
     p = new (&b) B [-4][5];       // { dg-error "size of array is negative" }
-    p = new (&b) B [-6][-7];      // { dg-error "size of array is negative" }
+    p = new (&b) B [-6][-7];      // { dg-error "size of array is negative|narrowing conversion" }
 
     p = new char [1 - 2];         // { dg-error "size of array is negative" }
     p = new (p) char [2 - 3];     // { dg-error "size of array is negative" }
     p = new A [2 < 1 ? -1 : -2];  // { dg-error "size of array is negative" }
     p = new (p) B [2 - 3 * 2];    // { dg-error "size of array is negative" }
-    p = new (&b) B [1][2 - 3 * 2];// { dg-error "size of array is negative" }
+    p = new (&b) B [1][2 - 3 * 2];// { dg-error "size of array|narrowing conversion" }
 }
 
 void test_constant_expression ()
@@ -79,35 +79,35 @@ void test_constant_expression ()
 
     // Verify constant expression.
     p = new char [i1];           // { dg-error "size of array is negative" }
-    p = new char [2][i3];        // { dg-error "size of array is negative" }
+    p = new char [2][i3];        // { dg-error "size of array is|narrowing conversion" }
     p = new char [i4][5];        // { dg-error "size of array is negative" }
-    p = new char [i6][i7];       // { dg-error "size of array is negative" }
+    p = new char [i6][i7];       // { dg-error "size of array is|narrowing conversion" }
 
     p = new (p) char [i1];       // { dg-error "size of array is negative" }
-    p = new (p) char [2][i3];    // { dg-error "size of array is negative" }
+    p = new (p) char [2][i3];    // { dg-error "size of array is|narrowing conversion" }
     p = new (p) char [i4][5];    // { dg-error "size of array is negative" }
-    p = new (p) char [i6][i7];   // { dg-error "size of array is negative" }
+    p = new (p) char [i6][i7];   // { dg-error "size of array is|narrowing conversion" }
 
     p = new (p) A [i1];          // { dg-error "size of array is negative" }
-    p = new (p) A [2][i3];       // { dg-error "size of array is negative" }
+    p = new (p) A [2][i3];       // { dg-error "size of array is|narrowing conversion" }
     p = new (p) A [i4][5];       // { dg-error "size of array is negative" }
-    p = new (p) A [i6][i7];      // { dg-error "size of array is negative" }
+    p = new (p) A [i6][i7];      // { dg-error "size of array is|narrowing conversion" }
 
     p = new (p) B [i1];          // { dg-error "size of array is negative" }
-    p = new (p) B [2][i3];       // { dg-error "size of array is negative" }
+    p = new (p) B [2][i3];       // { dg-error "size of array is|narrowing conversion" }
     p = new (p) B [i4][5];       // { dg-error "size of array is negative" }
-    p = new (p) B [i6][i7];      // { dg-error "size of array is negative" }
+    p = new (p) B [i6][i7];      // { dg-error "size of array is|narrowing conversion" }
 
     p = new (&b) B [i1];          // { dg-error "size of array is negative" }
-    p = new (&b) B [2][i3];       // { dg-error "size of array is negative" }
+    p = new (&b) B [2][i3];       // { dg-error "size of array is|narrowing conversion" }
     p = new (&b) B [i4][5];       // { dg-error "size of array is negative" }
-    p = new (&b) B [i6][i7];      // { dg-error "size of array is negative" }
+    p = new (&b) B [i6][i7];      // { dg-error "size of array is|narrowing conversion" }
 
     p = new short [i1 - 2];       // { dg-error "size of array is negative" }
     p = new (p) bool [i2 - 3];    // { dg-error "size of array is negative" }
     p = new A [2 < 1 ? i1 : i2];  // { dg-error "size of array is negative" }
     p = new (p) B [2 + i3 * 2];   // { dg-error "size of array is negative" }
-    p = new (&b) B [1][i1 - 3 * 2];// { dg-error "size of array is negative" }
+    p = new (&b) B [1][i1 - 3 * 2];// { dg-error "size of array|narrowing conversion" }
 }
 
 void test_constexpr ()
@@ -132,33 +132,33 @@ void test_constexpr ()
 
     // Verify constant expression.
     p = new char [s1];           // { dg-error "size of array is negative" }
-    p = new char [2][s3];        // { dg-error "size of array is negative" }
+    p = new char [2][s3];        // { dg-error "size of array is|narrowing conversion" }
     p = new char [s4][5];        // { dg-error "size of array is negative" }
-    p = new char [s6][s7];       // { dg-error "size of array is negative" }
+    p = new char [s6][s7];       // { dg-error "size of array is|narrowing conversion" }
 
     p = new (p) char [s1];       // { dg-error "size of array is negative" }
-    p = new (p) char [2][s3];    // { dg-error "size of array is negative" }
+    p = new (p) char [2][s3];    // { dg-error "size of array is|narrowing conversion" }
     p = new (p) char [s4][5];    // { dg-error "size of array is negative" }
-    p = new (p) char [s6][s7];   // { dg-error "size of array is negative" }
+    p = new (p) char [s6][s7];   // { dg-error "size of array is|narrowing conversion" }
 
     p = new (p) A [s1];          // { dg-error "size of array is negative" }
-    p = new (p) A [2][s3];       // { dg-error "size of array is negative" }
+    p = new (p) A [2][s3];       // { dg-error "size of array is|narrowing conversion" }
     p = new (p) A [s4][5];       // { dg-error "size of array is negative" }
-    p = new (p) A [s6][s7];      // { dg-error "size of array is negative" }
+    p = new (p) A [s6][s7];      // { dg-error "size of array is|narrowing conversion" }
 
     p = new (p) B [s1];          // { dg-error "size of array is negative" }
-    p = new (p) B [2][s3];       // { dg-error "size of array is negative" }
+    p = new (p) B [2][s3];       // { dg-error "size of array is|narrowing conversion" }
     p = new (p) B [s4][5];       // { dg-error "size of array is negative" }
-    p = new (p) B [s6][s7];      // { dg-error "size of array is negative" }
+    p = new (p) B [s6][s7];      // { dg-error "size of array is|narrowing conversion" }
 
     p = new (&b) B [s1];          // { dg-error "size of array is negative" }
-    p = new (&b) B [2][s3];       // { dg-error "size of array is negative" }
+    p = new (&b) B [2][s3];       // { dg-error "size of array is|narrowing conversion" }
     p = new (&b) B [s4][5];       // { dg-error "size of array is negative" }
-    p = new (&b) B [s6][s7];      // { dg-error "size of array is negative" }
+    p = new (&b) B [s6][s7];      // { dg-error "size of array is|narrowing conversion" }
 
     p = new int [s1 + s2];           // { dg-error "size of array is negative" }
     p = new (p) long [2 * s3];       // { dg-error "size of array is negative" }
     p = new A [s2 < s1 ? s1 : s2];   // { dg-error "size of array is negative" }
     p = new (p) B [s7 - s2 * 2];     // { dg-error "size of array is negative" }
-    p = new (&b) B [9][s4 - s1 * 2]; // { dg-error "size of array is negative" }
+    p = new (&b) B [9][s4 - s1 * 2]; // { dg-error "size of array is|narrowing conversion" }
 }
diff --git gcc/testsuite/g++.dg/other/fold1.C gcc/testsuite/g++.dg/other/fold1.C
index 23d34546e0b..bf074038b04 100644
--- gcc/testsuite/g++.dg/other/fold1.C
+++ gcc/testsuite/g++.dg/other/fold1.C
@@ -4,5 +4,5 @@
 struct A
 {
     static const int i = i;  // { dg-error "not declared" }
-    int x[i];		     // { dg-error "constant-expression" }
+    int x[i];		     // { dg-error "constant-expression|narrowing conversion" }
 };
diff --git gcc/testsuite/g++.dg/other/vrp1.C gcc/testsuite/g++.dg/other/vrp1.C
index 0a798c9954e..466a15b4cbb 100644
--- gcc/testsuite/g++.dg/other/vrp1.C
+++ gcc/testsuite/g++.dg/other/vrp1.C
@@ -9,4 +9,4 @@ long long mod (long long l, long long r)
     return 0LL;
   return l % r;
 }
-template long long mod<-0x8000000000000000LL> (long long, long long);
+template long long mod<-0x8000000000000000LL> (long long, long long); // { dg-error "template-id" "" { target { c++11 } } }
diff --git gcc/testsuite/g++.dg/parse/array-size2.C gcc/testsuite/g++.dg/parse/array-size2.C
index d0bc47fe746..997b95eed1a 100644
--- gcc/testsuite/g++.dg/parse/array-size2.C
+++ gcc/testsuite/g++.dg/parse/array-size2.C
@@ -14,7 +14,7 @@ extern void bar (char *, char *);
 void
 foo (void)
 {
-  char g[(char *) &((struct S *) 0)->b - (char *) 0]; // { dg-error "constant" }
+  char g[(char *) &((struct S *) 0)->b - (char *) 0]; // { dg-error "constant|narrowing conversion" }
   char h[(__SIZE_TYPE__) &((struct S *) 8)->b];	      // { dg-error "constant" }
   bar (g, h);
 }
diff --git gcc/testsuite/g++.dg/template/char1.C gcc/testsuite/g++.dg/template/char1.C
index 51e72e7ad06..a6cffaaf024 100644
--- gcc/testsuite/g++.dg/template/char1.C
+++ gcc/testsuite/g++.dg/template/char1.C
@@ -1,4 +1,5 @@
 template <class CharType, CharType line_terminator = 0>
 class String {};
 
-String<signed char, 255> s;		// { dg-warning "overflow" }
+String<signed char, 255> s;		// { dg-error "narrowing conversion" "" { target c++11 } }
+// { dg-warning "overflow" "" { target c++98_only } .-1 }
diff --git gcc/testsuite/g++.dg/template/dependent-name3.C gcc/testsuite/g++.dg/template/dependent-name3.C
index bbe6fb66266..f9d14055a11 100644
--- gcc/testsuite/g++.dg/template/dependent-name3.C
+++ gcc/testsuite/g++.dg/template/dependent-name3.C
@@ -11,7 +11,7 @@ template<int I> struct A
 template<int N> struct B
 {
   int x[A<N>::zero];       // { dg-error "zero" }
-  int y[A<N>::minus_one];  // { dg-error "negative" }
+  int y[A<N>::minus_one];  // { dg-error "size of array|narrowing conversion" }
 };
 
 B<0> b;

	Marek


Index Nav: [Date Index] [Subject Index] [Author Index] [Thread Index]
Message Nav: [Date Prev] [Date Next] [Thread Prev] [Thread Next]