This is the mail archive of the
gcc-patches@gcc.gnu.org
mailing list for the GCC project.
Re: C++ PATCH for c++/57891, narrowing conversions in non-type template arguments
- From: David Malcolm <dmalcolm at redhat dot com>
- To: Jason Merrill <jason at redhat dot com>, Marek Polacek <polacek at redhat dot com>
- Cc: gcc-patches List <gcc-patches at gcc dot gnu dot org>
- Date: Mon, 13 Aug 2018 20:58:52 -0400
- Subject: Re: C++ PATCH for c++/57891, narrowing conversions in non-type template arguments
- References: <CADzB+2mMpGkwfY3mCKhwgFiJxmQ6wbU+WUQtvpXKJxQaprXn8Q@mail.gmail.com> <20180703185805.GH5927@redhat.com> <CADzB+2kg8nk2EmgcKqZ=S9HVUV_0LhOHKeOdoERcvnt2ZKpLLA@mail.gmail.com> <CADzB+2=Z7CXZMECZcrx4D+p+OpsLyHisXuMKP-SJCHePLc6zfw@mail.gmail.com> <20180723204912.GH29486@redhat.com> <CADzB+2=-uJtJQCijV534Xs9nqH_Xqm=WUgzuPP-RQdDvFxvNJQ@mail.gmail.com> <20180809205940.GJ4317@redhat.com> <CADzB+2=b=pPOCbTK6_ze3m-imeEkqTaS6e54OjM5Fz=aByh7yA@mail.gmail.com> <20180811141350.GL4317@redhat.com> <CADzB+2n-GqOSOT=j5JHuTPxHb-WYp4z5a5K8Tz5QQObTQq9RqQ@mail.gmail.com> <20180813222438.GR4317@redhat.com> <CADzB+2kYusOVgKbaW=OgA6fmOLc6pynTtzU0Lp6Qo0vTg0xQXA@mail.gmail.com>
On Tue, 2018-08-14 at 11:02 +1200, Jason Merrill wrote:
>
>
> On Tue, Aug 14, 2018, 10:24 AM Marek Polacek <polacek@redhat.com>
> wrote:
> > On Mon, Aug 13, 2018 at 10:14:21PM +1200, Jason Merrill wrote:
> > > >> >> > --- 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,
> > > >> >>
> > > >> >> It should work to use location_of (osize) here.
> > > >> >
> > > >> > I dropped this hunk altogether. Because location_of will
> > use
> > > >> > DECL_SOURCE_LOCATION for DECLs, the error message will point
> > to the declaration
> > > >> > itself, not the use. I don't really care either way.
> > > >>
> > > >> We want the message to point to the use, which location_of
> > (osize)
> > > >> will provide, since it should still have a location wrapper
> > around a
> > > >> DECL.
> > > >
> > > > location_of (osize) is actually the same as location_of (size)
> > so that didn't
> > > > change anything.
> > >
> > > Hunh, that's strange. Why isn't osize the unfolded expression?
> > Where
> > > is the location wrapper getting stripped?
> >
> > I actually see that it didn't have the location wrapper at the
> > start.
> > The array bound is parsed in cp_parser_direct_new_declarator, and
> > we
> > never called maybe_wrap_with_location to add the wrapper. I don't
> > know
> > where that's supposed to happen.
Currently we only call maybe_wrap_with_location in a few select places
in the C++ FE: for the arguments of call sites, and a few other places.
I hope to overhaul this at some point in gcc 9 stage 1, but there may
be a case for adding more special-cases.
> > This quick hack works
> >
> > --- a/gcc/cp/parser.c
> > +++ b/gcc/cp/parser.c
> > @@ -8681,6 +8681,7 @@ cp_parser_direct_new_declarator (cp_parser*
> > parser)
> > cp_parser_require (parser, CPP_CLOSE_SQUARE,
> > RT_CLOSE_SQUARE);
> >
> > /* Add this bound to the declarator. */
> > + expression = maybe_wrap_with_location (expression, token-
> > >location);
> > declarator = make_array_declarator (declarator, expression);
> >
> > /* If the next token is not a `[', then there are no more
> >
> > but that feels too ad-hoc and beyond the scope of this fix.
>
> David, does this look right to you?
The usage of token->location struck me as potentially wrong. There
have been plenty of places in our frontends where we've erroneously
used a token's location for an expression, rather than that of the
whole expression (due to grafting in location ranges in the gcc 6
timeframe); this jumped out at me as maybe one of these cases.
If I'm reading it right, the code is parsing this production:
direct-new-declarator:
[ expression ]
direct-new-declarator [constant-expression]
What's an example of a string that matches this part of the grammar?
Is it something like the highlighted part of:
foo = new char[-42];
^^^^^
?
We parse the expression here:
expression = cp_parser_expression (parser);
cp_parser_expression returns a cp_expr, which would implicitly wrap the
location if we have, say a integer constant. In the example above,
this would capture the location of the constant:
foo = new char[-42];
^~~
However, we throw away the "on the side" location information since
"expression" is a tree, rather than a cp_expr.
token->location is purely the location of the opening '[' token. That
sounds like it's also throwing away location information.
What is it that's being parsed, and what should the location be?
If this is for issuing a diagnostic like:
error: size of array is negative
then what should the user see? Presumably something like:
error: size of array is negative
foo = new char[-42];
^~~
or:
error: size of array is negative
foo = new char[-42];
~^~~~
or somesuch? For the former, then converting expression to a cp_expr
and adding:
expression = expression.maybe_add_location_wrapper ();
might work.
I have a patch to overhaul all of this which I'll try to finish and
post (but I'm knee-deep in something else right now).
Hope this is constructive
Dave
> > > > The code below uses input_location which is why I went with
> > > > it in the first place. So, should I change this to
> > input_location?
> > >
> > > I suppose so.
> >
> > Here's the version with input_location.
> >
> > Bootstrapped/regtested on x86_64-linux, ok for trunk?
>
> Ok.
>
> > 2018-08-13 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. Give error if expr is error
> > node.
> > (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
> > instead of
> > location_of.
> > * pt.c (convert_nontype_argument): Return NULL_TREE if
> > tf_error.
> > * typeck2.c (check_narrowing): Don't warn for
> > instantiation-dependent
> > expressions. Call maybe_constant_value instead of
> > fold_non_dependent_expr. 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-47969.C: Adjust dg-error.
> > * g++.dg/cpp0x/constexpr-ex2.C: Likewise.
> > * g++.dg/cpp0x/constexpr-targ.C: Likewise.
> > * g++.dg/cpp0x/scoped_enum2.C: Likewise.
> > * g++.dg/ext/stmtexpr15.C: Likewise.
> > * g++.dg/gomp/pr47963.C: Likewise.
> > * g++.dg/init/new37.C: Likewise.
> > * g++.dg/init/new43.C: Likewise.
> > * g++.dg/other/fold1.C: Likewise.
> > * g++.dg/parse/array-size2.C: Likewise.
> > * g++.dg/template/dependent-name3.C: Likewise.
> > * g++.dg/cpp0x/constexpr-data2.C: Add dg-error.
> > * g++.dg/other/vrp1.C: Likewise.
> > * g++.dg/template/char1.C: Likewise.
> >
> > diff --git gcc/cp/call.c gcc/cp/call.c
> > index 209c1fd2f0e..62654a9e407 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,9 +4155,18 @@ 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;
> > + {
> > + if (complain & tf_error)
> > + error_at (loc, "could not convert %qE from %qH to %qI",
> > expr,
> > + TREE_TYPE (expr), type);
> > + expr = error_mark_node;
> > + }
> >
> > /* Free all the conversions we allocated. */
> > obstack_free (&conversion_obstack, p);
> > @@ -7142,7 +7154,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 94a85b72d2b..9608cf5334b 100644
> > --- gcc/cp/cp-tree.h
> > +++ gcc/cp/cp-tree.h
> > @@ -7397,7 +7397,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 97f1cfb792e..9a2e3247946 100644
> > --- gcc/cp/decl.c
> > +++ gcc/cp/decl.c
> > @@ -9702,7 +9702,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 7fcf5d6b2d3..cbb7b8ea853 100644
> > --- gcc/cp/pt.c
> > +++ gcc/cp/pt.c
> > @@ -6682,7 +6682,9 @@ convert_nontype_argument (tree type, tree
> > expr, tsubst_flags_t complain)
> > template-parameter. */
> > 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 (complain & tf_error) ? 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 72515d9ece7..674d08762b5 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,9 @@ 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))
> > return ok;
> >
> > if (BRACE_ENCLOSED_INITIALIZER_P (init)
> > @@ -902,7 +906,11 @@ check_narrowing (tree type, tree init,
> > tsubst_flags_t complain)
> > return ok;
> > }
> >
> > - init = fold_non_dependent_expr (init, complain);
> > + init = maybe_constant_value (init);
> > +
> > + /* 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)
> > @@ -967,7 +975,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 +985,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 +998,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/Wnarrowing10.C
> > gcc/testsuite/g++.dg/cpp0x/Wnarrowing10.C
> > index e69de29bb2d..8414b53e342 100644
> > --- gcc/testsuite/g++.dg/cpp0x/Wnarrowing10.C
> > +++ gcc/testsuite/g++.dg/cpp0x/Wnarrowing10.C
> > @@ -0,0 +1,5 @@
> > +// PR c++/57891
> > +// { dg-do compile { target c++11 } }
> > +
> > +template<int N, unsigned char M = N> struct S { char a[N]; };
> > +S<1000> s; // { dg-error "narrowing conversion" }
> > diff --git gcc/testsuite/g++.dg/cpp0x/Wnarrowing6.C
> > gcc/testsuite/g++.dg/cpp0x/Wnarrowing6.C
> > index e69de29bb2d..989d277cd00 100644
> > --- gcc/testsuite/g++.dg/cpp0x/Wnarrowing6.C
> > +++ gcc/testsuite/g++.dg/cpp0x/Wnarrowing6.C
> > @@ -0,0 +1,8 @@
> > +// PR c++/57891
> > +// { dg-do compile { target c++11 } }
> > +
> > +template<unsigned int> struct A {};
> > +A<-1> a; // { dg-error "narrowing conversion" }
> > +
> > +template<signed char> struct B {};
> > +B<1000> b; // { dg-error "narrowing conversion" }
> > diff --git gcc/testsuite/g++.dg/cpp0x/Wnarrowing7.C
> > gcc/testsuite/g++.dg/cpp0x/Wnarrowing7.C
> > index e69de29bb2d..099fdfb7d81 100644
> > --- gcc/testsuite/g++.dg/cpp0x/Wnarrowing7.C
> > +++ gcc/testsuite/g++.dg/cpp0x/Wnarrowing7.C
> > @@ -0,0 +1,9 @@
> > +// PR c++/57891
> > +// { dg-do compile { target c++11 } }
> > +// { dg-options "-Wno-narrowing" }
> > +
> > +template<unsigned int> struct A {};
> > +A<-1> a;
> > +
> > +template<signed char> struct B {};
> > +B<1000> b; // { dg-warning "overflow" }
> > diff --git gcc/testsuite/g++.dg/cpp0x/Wnarrowing8.C
> > gcc/testsuite/g++.dg/cpp0x/Wnarrowing8.C
> > index e69de29bb2d..39c924c9c6c 100644
> > --- gcc/testsuite/g++.dg/cpp0x/Wnarrowing8.C
> > +++ gcc/testsuite/g++.dg/cpp0x/Wnarrowing8.C
> > @@ -0,0 +1,6 @@
> > +// PR c++/57891
> > +// { dg-do compile { target c++11 } }
> > +
> > +struct X { constexpr operator int () { return 1000; } };
> > +template<signed char> struct C {};
> > +C<X{}> c; // { dg-error "narrowing conversion" }
> > diff --git gcc/testsuite/g++.dg/cpp0x/Wnarrowing9.C
> > gcc/testsuite/g++.dg/cpp0x/Wnarrowing9.C
> > index e69de29bb2d..bc8a736ecb9 100644
> > --- gcc/testsuite/g++.dg/cpp0x/Wnarrowing9.C
> > +++ gcc/testsuite/g++.dg/cpp0x/Wnarrowing9.C
> > @@ -0,0 +1,6 @@
> > +// PR c++/57891
> > +// { dg-do compile { target c++11 } }
> > +
> > +// N is value-dependent, don't warn.
> > +template<int N> struct S { char a[N]; }; // { dg-bogus "narrowing
> > conversion" }
> > +S<1> s;
> > diff --git gcc/testsuite/g++.dg/cpp0x/constexpr-47969.C
> > gcc/testsuite/g++.dg/cpp0x/constexpr-47969.C
> > index 933831b94de..201ee17b41b 100644
> > --- gcc/testsuite/g++.dg/cpp0x/constexpr-47969.C
> > +++ gcc/testsuite/g++.dg/cpp0x/constexpr-47969.C
> > @@ -8,4 +8,4 @@ struct A
> >
> > constexpr A a = A();
> >
> > -int ar[a]; // { dg-error "has non-integral type" }
> > +int ar[a]; // { dg-error "could not convert|has non-integral type"
> > }
> > 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/cpp0x/constexpr-ex2.C
> > gcc/testsuite/g++.dg/cpp0x/constexpr-ex2.C
> > index 34b557ce76e..ceae9cb75d3 100644
> > --- gcc/testsuite/g++.dg/cpp0x/constexpr-ex2.C
> > +++ gcc/testsuite/g++.dg/cpp0x/constexpr-ex2.C
> > @@ -18,5 +18,5 @@ constexpr A a = 42;
> >
> > X<a> x; // OK: unique conversion to int
> > int ar[X<a>::i]; // also OK
> > -int ary[a]; // { dg-error "ambiguous|conversion|array" } ambiguous
> > conversion
> > +int ary[a]; // { dg-error "could not
> > convert|ambiguous|conversion|array" } ambiguous conversion
> >
> > diff --git gcc/testsuite/g++.dg/cpp0x/constexpr-targ.C
> > gcc/testsuite/g++.dg/cpp0x/constexpr-targ.C
> > index 98bb502249a..0f1f113f92f 100644
> > --- gcc/testsuite/g++.dg/cpp0x/constexpr-targ.C
> > +++ gcc/testsuite/g++.dg/cpp0x/constexpr-targ.C
> > @@ -10,4 +10,4 @@ struct B
> > { };
> >
> > constexpr A a { };
> > -B<a> b; // { dg-error "template
> > argument|converted constant" }
> > +B<a> b; // { dg-error "template
> > argument|converted constant|could not convert" }
> > diff --git gcc/testsuite/g++.dg/cpp0x/scoped_enum2.C
> > gcc/testsuite/g++.dg/cpp0x/scoped_enum2.C
> > index bb8ad750bd0..456b0daedd1 100644
> > --- gcc/testsuite/g++.dg/cpp0x/scoped_enum2.C
> > +++ gcc/testsuite/g++.dg/cpp0x/scoped_enum2.C
> > @@ -4,8 +4,8 @@ enum class E { e = 10 };
> > enum E2 { e2 = 10 };
> >
> > struct C {
> > - int arr[E::e]; // { dg-error "non-integral type" }
> > + int arr[E::e]; // { dg-error "could not convert|non-integral
> > type" }
> > int arr2[E2::e2]; // OK
> > - int i: E::e; // { dg-error "non-integral type" }
> > + int i: E::e; // { dg-error "could not convert|non-integral
> > type" }
> > int i2: E2::e2; // OK
> > };
> > diff --git gcc/testsuite/g++.dg/ext/stmtexpr15.C
> > gcc/testsuite/g++.dg/ext/stmtexpr15.C
> > index 83a831cdd4c..1a60a0d3cad 100644
> > --- gcc/testsuite/g++.dg/ext/stmtexpr15.C
> > +++ gcc/testsuite/g++.dg/ext/stmtexpr15.C
> > @@ -3,5 +3,5 @@
> >
> > void foo()
> > {
> > - int x[({ return; })]; // { dg-error "non-
> > integral" }
> > + int x[({ return; })]; // { dg-error "could not
> > convert|non-integral" }
> > }
> > diff --git gcc/testsuite/g++.dg/gomp/pr47963.C
> > gcc/testsuite/g++.dg/gomp/pr47963.C
> > index 5b0c60b80a4..6be4c0e18fb 100644
> > --- gcc/testsuite/g++.dg/gomp/pr47963.C
> > +++ gcc/testsuite/g++.dg/gomp/pr47963.C
> > @@ -5,7 +5,7 @@
> > void
> > foo (float n)
> > {
> > - int A[n][n]; // { dg-error "has non-integral type|converted
> > constant expression" }
> > + int A[n][n]; // { dg-error "could not convert|has non-integral
> > type|converted constant expression" }
> > #pragma omp parallel private(A)
> > ;
> > }
> > diff --git gcc/testsuite/g++.dg/init/new37.C
> > gcc/testsuite/g++.dg/init/new37.C
> > index 9ecbfd7903d..2a42fda33dc 100644
> > --- gcc/testsuite/g++.dg/init/new37.C
> > +++ gcc/testsuite/g++.dg/init/new37.C
> > @@ -32,7 +32,7 @@ template <typename T>
> > void *
> > callnew_fail_3()
> > {
> > - return new T[2][T::n]; // { dg-error "size of array has non-
> > integral type|converted constant expression" }
> > + return new T[2][T::n]; // { dg-error "could not convert|size of
> > array has non-integral type|converted constant expression" }
> > }
> >
> > struct T1 {
> > diff --git gcc/testsuite/g++.dg/init/new43.C
> > gcc/testsuite/g++.dg/init/new43.C
> > index 9b0866720fe..aa40b429469 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|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|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|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|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|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|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|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|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|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|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|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|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|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|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|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|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|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|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|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|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|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|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|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|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|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|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|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|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|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|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|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