On Tue, Jul 03, 2018 at 04:27:33PM -0400, Jason Merrill wrote: > On Tue, Jul 3, 2018 at 3:41 PM, Jason Merrill <ja...@redhat.com> wrote: > > On Tue, Jul 3, 2018 at 2:58 PM, Marek Polacek <pola...@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 <pola...@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 <pola...@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 <pola...@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 <pola...@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 <pola...@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