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: Marek Polacek <polacek at redhat dot com>
- To: Jason Merrill <jason at redhat dot com>
- Cc: GCC Patches <gcc-patches at gcc dot gnu dot org>
- Date: Thu, 9 Aug 2018 16:59:40 -0400
- Subject: Re: C++ PATCH for c++/57891, narrowing conversions in non-type template arguments
- References: <20180627165343.GC4896@redhat.com> <CADzB+2nEwPa9mjqeLd4Zh_hOa93YTrp46SXcORx+y==fRs70SA@mail.gmail.com> <20180629195834.GB5927@redhat.com> <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>
On Mon, Aug 06, 2018 at 12:02:31AM +1000, Jason Merrill wrote:
> > 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.
>
> Looks good.
>
> >> >> @@ -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.
>
> Yes, that's normal. The problem is in build_converted_constant_expr:
>
> if (conv)
> expr = convert_like (conv, expr, complain);
> else
> expr = error_mark_node;
>
> Here when setting expr to error_mark_node I forgot to give an error if
> (complain & tf_error).
Done. A few testcases needed adjusting but nothing surprising.
> >> >> + /* 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.)
>
> Why later?
So this was this wrong error:
https://gcc.gnu.org/ml/gcc-patches/2018-07/msg00159.html
which was confusing. But I noticed it's because we instantiate 'size' twice:
in compute_array_index_type:
size = instantiate_non_dependent_expr_sfinae (size, complain);
size = build_converted_constant_expr (size_type_node, size, complain);
size = maybe_constant_value (size);
and then in check_narrowing:
init = fold_non_dependent_expr (init, complain);
(in this case, size is a call to constexpr user-defined conversion).
But check_narrowing now returns early if instantiation_dependent_expression_p,
so I thought perhaps we could simply call maybe_constant_value which fixes this
problem and doesn't regress anything. Does that seem like a sensible thing
to do?
> > --- 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.
Bootstrapped/regtested on x86_64-linux, ok for trunk?
2018-08-09 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.
* 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/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 7763d53ee65..0b886df12f7 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..cbb6f2d9da8 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 ()
@@ -71,43 +71,43 @@ void test_constant_expression ()
static const signed char i1 = -1;
static const signed short i2 = -2;
- static const signed int i3 = -3;
+ static const signed int i3 = -3; // { dg-error "size of array" "" { target c++11 } }
static const signed long i4 = -4;
static const signed long long i5 = -5;
static const int i6 = -6;
- static const int i7 = -7;
+ static const int i7 = -7; // { dg-error "size of array" "" { target c++11 } }
// 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 negative|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 negative|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 negative|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 negative|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 negative|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 negative|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 negative|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 negative|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 negative|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 negative|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..da62b187115 100644
--- gcc/testsuite/g++.dg/template/dependent-name3.C
+++ gcc/testsuite/g++.dg/template/dependent-name3.C
@@ -5,13 +5,13 @@
template<int I> struct A
{
static const int zero = 0;
- static const int minus_one = -1;
+ static const int minus_one = -1; // { dg-error "size of array" "" { target c++11} }
};
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;