From patchwork Fri May 12 18:33:01 2017 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 8bit X-Patchwork-Submitter: Ville Voutilainen X-Patchwork-Id: 761811 Return-Path: X-Original-To: incoming@patchwork.ozlabs.org Delivered-To: patchwork-incoming@bilbo.ozlabs.org Received: from sourceware.org (server1.sourceware.org [209.132.180.131]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by ozlabs.org (Postfix) with ESMTPS id 3wPdrv0rxlz9rxw for ; Sat, 13 May 2017 04:33:15 +1000 (AEST) Authentication-Results: ozlabs.org; dkim=pass (1024-bit key; unprotected) header.d=gcc.gnu.org header.i=@gcc.gnu.org header.b="qKV9v5h3"; dkim-atps=neutral DomainKey-Signature: a=rsa-sha1; c=nofws; d=gcc.gnu.org; h=list-id :list-unsubscribe:list-archive:list-post:list-help:sender :mime-version:in-reply-to:references:from:date:message-id :subject:to:cc:content-type; q=dns; s=default; b=sOjEU711EIg6gQz 3rxEpFKl/QYRQrKNwrJeVRDN+7OIlpgyUSfVy+A3wFEOM708g47Db9chSJsHTX8n w+0PVjes6NxBb09g3qxYQEdoBlUh0OKfBcLQyHWn9N/s4WQMVEW7mJtFcf1ODJN3 n5e16QtzGmuzn8cRn8d1xHb9JsPw= DKIM-Signature: v=1; a=rsa-sha1; c=relaxed; d=gcc.gnu.org; h=list-id :list-unsubscribe:list-archive:list-post:list-help:sender :mime-version:in-reply-to:references:from:date:message-id :subject:to:cc:content-type; s=default; bh=gczKtgdzT1B6lgTA0zWeT BAGq3E=; b=qKV9v5h3+Z8B/Plq5RznvZfj62YdASWAYAGOlrAeMCN1ysRcm7q0O xZ8wdmD+4QddDoCTS9qj+VGSAMK6qA+ZY+ugbnDYR2UIW76Ny4vNzLU3CEMVeXL3 tX7QhOGcBR/nNY/jdipthx1CfrhGbDHurmqMvqB7T5ILZajKIeicqA= Received: (qmail 20119 invoked by alias); 12 May 2017 18:33:04 -0000 Mailing-List: contact gcc-patches-help@gcc.gnu.org; run by ezmlm Precedence: bulk List-Id: List-Unsubscribe: List-Archive: List-Post: List-Help: Sender: gcc-patches-owner@gcc.gnu.org Delivered-To: mailing list gcc-patches@gcc.gnu.org Received: (qmail 20095 invoked by uid 89); 12 May 2017 18:33:04 -0000 Authentication-Results: sourceware.org; auth=none X-Virus-Found: No X-Spam-SWARE-Status: No, score=-24.2 required=5.0 tests=AWL, BAYES_00, FREEMAIL_FROM, GIT_PATCH_0, GIT_PATCH_1, GIT_PATCH_2, GIT_PATCH_3, RCVD_IN_DNSWL_NONE, RCVD_IN_SORBS_SPAM, SPF_PASS autolearn=ham version=3.3.2 spammy= X-Spam-User: qpsmtpd, 2 recipients X-HELO: mail-oi0-f42.google.com Received: from mail-oi0-f42.google.com (HELO mail-oi0-f42.google.com) (209.85.218.42) by sourceware.org (qpsmtpd/0.93/v0.84-503-g423c35a) with ESMTP; Fri, 12 May 2017 18:33:00 +0000 Received: by mail-oi0-f42.google.com with SMTP id w10so75668519oif.0; Fri, 12 May 2017 11:33:03 -0700 (PDT) X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:mime-version:in-reply-to:references:from:date :message-id:subject:to:cc; bh=EZn4fMw9agR93QNb8zCqaFUIODS0Fzxd1xbJTVKxAGc=; b=g8MbCOx8Zyt8OWV2KLD9pIqdsANvIM5113kQvAKTI2WB7ZKf9ToEnOMyW/I0xHaDTz r5MGMCgrXZi18k9mz3DKOw1LQlD+BMRr5Nzl7b0KGZDYtK87kLCc/N9f9MIpzzumLRdo P1W66pRRAXEr+RVhMEbLdPBRNlrfvzz3r5H253kb+a9MdVPjZCE3sCnOC8zQ4P3tbPtI 68k9Jak8SCIxL8Jp4oqxw87OnOrzI34ihOuCgydaZsPzltN6ft1WqlaWJqd/MIQn1uQM unV6o7ogfV+K83ZXgX1EnBKO7InBL5PpYwLRKx3+P+qp7ihz4ZPRwRlBkf0nxrIHee/b aOqQ== X-Gm-Message-State: AODbwcCcZi3ImlJLA6FMuJFWENLMKciOC9SVedsTPEHrodftZ9K9Eub1 EV9rDSRu2SEgB3BNxc0M6dmHgC9MMg== X-Received: by 10.157.5.178 with SMTP id 47mr2564575otd.39.1494613981621; Fri, 12 May 2017 11:33:01 -0700 (PDT) MIME-Version: 1.0 Received: by 10.157.17.253 with HTTP; Fri, 12 May 2017 11:33:01 -0700 (PDT) In-Reply-To: References: From: Ville Voutilainen Date: Fri, 12 May 2017 21:33:01 +0300 Message-ID: Subject: Re: [C++ PATCH, RFC] Implement new C++ intrinsics __is_assignable and __is_constructible. To: =?UTF-8?Q?Daniel_Kr=C3=BCgler?= , Jason Merrill Cc: "gcc-patches@gcc.gnu.org" , "libstdc++" On 12 May 2017 at 14:15, Ville Voutilainen wrote: > On 12 May 2017 at 14:06, Daniel Krügler wrote: >> Your description sounds remotely similar to me to the current problem >> of __is_trivially_constructible intrinsic, which seems to instantiate >> the copy constructor definition albeit it (IMO) shouldn't: >> >> https://gcc.gnu.org/bugzilla/show_bug.cgi?id=80654 >> >> Could there be a similar cause? > > > Seems quite plausible to me. I would be happy to fix that bug in the > same go, but I'm a bit > lost as to what exactly causes the problem. constructible_expr in method.c does > build_special_member_call for the constructor and the destructor, so > perhaps there > are some flags that could make it behave. Well, now that Jason pointed out that cp_unevaluated_operand is the trick, here's a new patch that fixes that bug and passes the full testsuite on Linux-x64. 2017-05-12 Ville Voutilainen c-family/ Implement new C++ intrinsics __is_assignable and __is_constructible. * c-common.c (__is_assignable, __is_constructible): New. * c-common.h (RID_IS_ASSIGNABLE, RID_IS_CONSTRUCTIBLE): Likewise. cp/ PR c++/80654 PR c++/80682 Implement new C++ intrinsics __is_assignable and __is_constructible. * cp-tree.h (CPTK_IS_ASSIGNABLE, CPTK_IS_CONSTRUCTIBLE): New. (is_xible): New. * cxx-pretty-print.c (pp_cxx_trait_expression): Handle CPTK_IS_ASSIGNABLE and CPTK_IS_CONSTRUCTIBLE. * method.c (constructible_expr): Set cp_unevaluated. (is_xible_helper): New. (is_trivially_xible): Adjust. (is_xible): New. * parser.c (cp_parser_primary_expression): Handle RID_IS_ASSIGNABLE and RID_IS_CONSTRUCTIBLE. (cp_parser_trait_expr): Likewise. * semantics.c (trait_expr_value): Handle CPTK_IS_ASSIGNABLE and CPTK_IS_CONSTRUCTIBLE. testsuite/ * g++.dg/ext/80654.C: New. libstdc++-v3/ Implement new C++ intrinsics __is_assignable and __is_constructible. * include/std/type_traits (__do_is_static_castable_impl): Remove. (__is_static_castable_impl, __is_static_castable_safe): Likewise. (__is_static_castable, __do_is_direct_constructible_impl): Likewise. (__is_direct_constructible_impl): Likewise. (__is_direct_constructible_new_safe): Likewise. (__is_base_to_derived_ref, __is_lvalue_to_rvalue_ref): Likewise. (__is_direct_constructible_ref_cast): Likewise. (__is_direct_constructible_new, __is_direct_constructible): Likewise. (__do_is_nary_constructible_impl): Likewise. (__is_nary_constructible_impl, __is_nary_constructible): Likewise. (__is_constructible_impl): Likewise. (is_constructible): Call the intrinsic. (__is_assignable_helper): Remove. (is_assignable): Call the intrinsic. (is_trivially_constructible): Likewise. (is_trivially_assignable): Likewise. (testsuite/20_util/declval/requirements/1_neg.cc): Adjust. (testsuite/20_util/make_signed/requirements/typedefs_neg.cc): Likewise. (testsuite/20_util/make_unsigned/requirements/typedefs_neg.cc): Likewise. diff --git a/gcc/c-family/c-common.c b/gcc/c-family/c-common.c index ad686d2..369e112 100644 --- a/gcc/c-family/c-common.c +++ b/gcc/c-family/c-common.c @@ -514,6 +514,8 @@ const struct c_common_resword c_common_reswords[] = { "volatile", RID_VOLATILE, 0 }, { "wchar_t", RID_WCHAR, D_CXXONLY }, { "while", RID_WHILE, 0 }, + { "__is_assignable", RID_IS_ASSIGNABLE, D_CXXONLY }, + { "__is_constructible", RID_IS_CONSTRUCTIBLE, D_CXXONLY }, /* C++ transactional memory. */ { "synchronized", RID_SYNCHRONIZED, D_CXX_OBJC | D_TRANSMEM }, diff --git a/gcc/c-family/c-common.h b/gcc/c-family/c-common.h index 9e3982d..a986056 100644 --- a/gcc/c-family/c-common.h +++ b/gcc/c-family/c-common.h @@ -172,6 +172,7 @@ enum rid RID_IS_TRIVIALLY_ASSIGNABLE, RID_IS_TRIVIALLY_CONSTRUCTIBLE, RID_IS_TRIVIALLY_COPYABLE, RID_IS_UNION, RID_UNDERLYING_TYPE, + RID_IS_ASSIGNABLE, RID_IS_CONSTRUCTIBLE, /* C++11 */ RID_CONSTEXPR, RID_DECLTYPE, RID_NOEXCEPT, RID_NULLPTR, RID_STATIC_ASSERT, diff --git a/gcc/cp/cp-tree.h b/gcc/cp/cp-tree.h index 09b1364..154ba3c 100644 --- a/gcc/cp/cp-tree.h +++ b/gcc/cp/cp-tree.h @@ -927,7 +927,9 @@ enum cp_trait_kind CPTK_IS_TRIVIALLY_CONSTRUCTIBLE, CPTK_IS_TRIVIALLY_COPYABLE, CPTK_IS_UNION, - CPTK_UNDERLYING_TYPE + CPTK_UNDERLYING_TYPE, + CPTK_IS_ASSIGNABLE, + CPTK_IS_CONSTRUCTIBLE }; /* The types that we are processing. */ @@ -6112,6 +6114,7 @@ extern void use_thunk (tree, bool); extern bool trivial_fn_p (tree); extern tree forward_parm (tree); extern bool is_trivially_xible (enum tree_code, tree, tree); +extern bool is_xible (enum tree_code, tree, tree); extern tree get_defaulted_eh_spec (tree); extern tree unevaluated_noexcept_spec (void); extern void after_nsdmi_defaulted_late_checks (tree); diff --git a/gcc/cp/cxx-pretty-print.c b/gcc/cp/cxx-pretty-print.c index f76c30a..71d149a 100644 --- a/gcc/cp/cxx-pretty-print.c +++ b/gcc/cp/cxx-pretty-print.c @@ -2634,6 +2634,12 @@ pp_cxx_trait_expression (cxx_pretty_printer *pp, tree t) case CPTK_IS_LITERAL_TYPE: pp_cxx_ws_string (pp, "__is_literal_type"); break; + case CPTK_IS_ASSIGNABLE: + pp_cxx_ws_string (pp, "__is_assignable"); + break; + case CPTK_IS_CONSTRUCTIBLE: + pp_cxx_ws_string (pp, "__is_constructible"); + break; default: gcc_unreachable (); diff --git a/gcc/cp/method.c b/gcc/cp/method.c index 99e98cc..1fb1076 100644 --- a/gcc/cp/method.c +++ b/gcc/cp/method.c @@ -1164,6 +1164,7 @@ constructible_expr (tree to, tree from) { tree ctype = to; vec *args = NULL; + cp_unevaluated cp_uneval_guard; if (TREE_CODE (to) != REFERENCE_TYPE) to = cp_build_reference_type (to, /*rval*/false); tree ob = build_stub_object (to); @@ -1200,22 +1201,36 @@ constructible_expr (tree to, tree from) return expr; } -/* Returns true iff TO is trivially assignable (if CODE is MODIFY_EXPR) or +/* Returns a tree iff TO is assignable (if CODE is MODIFY_EXPR) or constructible (otherwise) from FROM, which is a single type for assignment or a list of types for construction. */ -bool -is_trivially_xible (enum tree_code code, tree to, tree from) +static tree +is_xible_helper (enum tree_code code, tree to, tree from, bool trivial) { - if (VOID_TYPE_P (to)) - return false; + if (VOID_TYPE_P (to) || ABSTRACT_CLASS_TYPE_P (to) + || (from && FUNC_OR_METHOD_TYPE_P (from) + && (TYPE_READONLY (from) || FUNCTION_REF_QUALIFIED (from)))) + return error_mark_node; tree expr; if (code == MODIFY_EXPR) expr = assignable_expr (to, from); - else if (from && TREE_CHAIN (from)) - return false; // only 0- and 1-argument ctors can be trivial + else if (trivial && from && TREE_CHAIN (from)) + return error_mark_node; // only 0- and 1-argument ctors can be trivial else expr = constructible_expr (to, from); + return expr; +} + +/* Returns true iff TO is trivially assignable (if CODE is MODIFY_EXPR) or + constructible (otherwise) from FROM, which is a single type for + assignment or a list of types for construction. */ + +bool +is_trivially_xible (enum tree_code code, tree to, tree from) +{ + tree expr; + expr = is_xible_helper (code, to, from, /*trivial*/true); if (expr == error_mark_node) return false; @@ -1223,6 +1238,19 @@ is_trivially_xible (enum tree_code code, tree to, tree from) return !nt; } +/* Returns true iff TO is assignable (if CODE is MODIFY_EXPR) or + constructible (otherwise) from FROM, which is a single type for + assignment or a list of types for construction. */ + +bool +is_xible (enum tree_code code, tree to, tree from) +{ + tree expr = is_xible_helper (code, to, from, /*trivial*/false); + if (expr == error_mark_node) + return false; + return !!expr; +} + /* Subroutine of synthesized_method_walk. Update SPEC_P, TRIVIAL_P and DELETED_P or give an error message MSG with argument ARG. */ diff --git a/gcc/cp/parser.c b/gcc/cp/parser.c index 17d2679..5986dd9 100644 --- a/gcc/cp/parser.c +++ b/gcc/cp/parser.c @@ -5135,6 +5135,8 @@ cp_parser_primary_expression (cp_parser *parser, case RID_IS_TRIVIALLY_CONSTRUCTIBLE: case RID_IS_TRIVIALLY_COPYABLE: case RID_IS_UNION: + case RID_IS_ASSIGNABLE: + case RID_IS_CONSTRUCTIBLE: return cp_parser_trait_expr (parser, token->keyword); // C++ concepts @@ -9686,6 +9688,14 @@ cp_parser_trait_expr (cp_parser* parser, enum rid keyword) case RID_DIRECT_BASES: kind = CPTK_DIRECT_BASES; break; + case RID_IS_ASSIGNABLE: + kind = CPTK_IS_ASSIGNABLE; + binary = true; + break; + case RID_IS_CONSTRUCTIBLE: + kind = CPTK_IS_CONSTRUCTIBLE; + variadic = true; + break; default: gcc_unreachable (); } diff --git a/gcc/cp/semantics.c b/gcc/cp/semantics.c index 7b2c101..f9f402e 100644 --- a/gcc/cp/semantics.c +++ b/gcc/cp/semantics.c @@ -9209,6 +9209,12 @@ trait_expr_value (cp_trait_kind kind, tree type1, tree type2) case CPTK_IS_UNION: return type_code1 == UNION_TYPE; + case CPTK_IS_ASSIGNABLE: + return is_xible (MODIFY_EXPR, type1, type2); + + case CPTK_IS_CONSTRUCTIBLE: + return is_xible (INIT_EXPR, type1, type2); + default: gcc_unreachable (); return false; @@ -9282,6 +9288,10 @@ finish_trait_expr (cp_trait_kind kind, tree type1, tree type2) return error_mark_node; break; + case CPTK_IS_ASSIGNABLE: + case CPTK_IS_CONSTRUCTIBLE: + break; + case CPTK_IS_TRIVIALLY_ASSIGNABLE: case CPTK_IS_TRIVIALLY_CONSTRUCTIBLE: if (!check_trait_type (type1) diff --git a/gcc/testsuite/g++.dg/ext/80654.C b/gcc/testsuite/g++.dg/ext/80654.C new file mode 100644 index 0000000..8679613 --- /dev/null +++ b/gcc/testsuite/g++.dg/ext/80654.C @@ -0,0 +1,18 @@ +// { dg-do compile { target c++11 } } + +template struct wrap +{ + T t; + wrap(const wrap& other) : t(other.t) {} +}; + +struct nocopy { + nocopy (const nocopy&) = delete; +}; + +int main () +{ + static_assert(!__is_trivially_constructible(wrap, + const wrap&), ""); + return 0; +} diff --git a/libstdc++-v3/include/std/type_traits b/libstdc++-v3/include/std/type_traits index aac7cff..00f647b 100644 --- a/libstdc++-v3/include/std/type_traits +++ b/libstdc++-v3/include/std/type_traits @@ -924,213 +924,10 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION : public __is_default_constructible_safe<_Tp>::type { }; - - // Implementation of is_constructible. - - // The hardest part of this trait is the binary direct-initialization - // case, because we hit into a functional cast of the form T(arg). - // This implementation uses different strategies depending on the - // target type to reduce the test overhead as much as possible: - // - // a) For a reference target type, we use a static_cast expression - // modulo its extra cases. - // - // b) For a non-reference target type we use a ::new expression. - struct __do_is_static_castable_impl - { - template(declval<_From>()))> - static true_type __test(int); - - template - static false_type __test(...); - }; - - template - struct __is_static_castable_impl - : public __do_is_static_castable_impl - { - typedef decltype(__test<_From, _To>(0)) type; - }; - - template - struct __is_static_castable_safe - : public __is_static_castable_impl<_From, _To>::type - { }; - - // __is_static_castable - template - struct __is_static_castable - : public integral_constant::value)> - { }; - - // Implementation for non-reference types. To meet the proper - // variable definition semantics, we also need to test for - // is_destructible in this case. - // This form should be simplified by a single expression: - // ::delete ::new _Tp(declval<_Arg>()), see c++/51222. - struct __do_is_direct_constructible_impl - { - template()))> - static true_type __test(int); - - template - static false_type __test(...); - }; - - template - struct __is_direct_constructible_impl - : public __do_is_direct_constructible_impl - { - typedef decltype(__test<_Tp, _Arg>(0)) type; - }; - - template - struct __is_direct_constructible_new_safe - : public __and_, - __is_direct_constructible_impl<_Tp, _Arg>> - { }; - - template - struct is_same; - - template - struct is_base_of; - - template - struct remove_reference; - - template, - is_function<_From>>>::value> - struct __is_base_to_derived_ref; - - template - struct is_constructible; - - // Detect whether we have a downcast situation during - // reference binding. - template - struct __is_base_to_derived_ref<_From, _To, true> - { - typedef typename remove_cv::type>::type __src_t; - typedef typename remove_cv::type>::type __dst_t; - typedef __and_<__not_>, - is_base_of<__src_t, __dst_t>, - __not_>> type; - static constexpr bool value = type::value; - }; - - template - struct __is_base_to_derived_ref<_From, _To, false> - : public false_type - { }; - - template, - is_rvalue_reference<_To>>::value> - struct __is_lvalue_to_rvalue_ref; - - // Detect whether we have an lvalue of non-function type - // bound to a reference-compatible rvalue-reference. - template - struct __is_lvalue_to_rvalue_ref<_From, _To, true> - { - typedef typename remove_cv::type>::type __src_t; - typedef typename remove_cv::type>::type __dst_t; - typedef __and_<__not_>, - __or_, - is_base_of<__dst_t, __src_t>>> type; - static constexpr bool value = type::value; - }; - - template - struct __is_lvalue_to_rvalue_ref<_From, _To, false> - : public false_type - { }; - - // Here we handle direct-initialization to a reference type as - // equivalent to a static_cast modulo overshooting conversions. - // These are restricted to the following conversions: - // a) A base class value to a derived class reference - // b) An lvalue to an rvalue-reference of reference-compatible - // types that are not functions - template - struct __is_direct_constructible_ref_cast - : public __and_<__is_static_castable<_Arg, _Tp>, - __not_<__or_<__is_base_to_derived_ref<_Arg, _Tp>, - __is_lvalue_to_rvalue_ref<_Arg, _Tp> - >>> - { }; - - template - struct __is_direct_constructible_new - : public conditional::value, - __is_direct_constructible_ref_cast<_Tp, _Arg>, - __is_direct_constructible_new_safe<_Tp, _Arg> - >::type - { }; - - template - struct __is_direct_constructible - : public __is_direct_constructible_new<_Tp, _Arg>::type - { }; - - // Since default-construction and binary direct-initialization have - // been handled separately, the implementation of the remaining - // n-ary construction cases is rather straightforward. We can use - // here a functional cast, because array types are excluded anyway - // and this form is never interpreted as a C cast. - struct __do_is_nary_constructible_impl - { - template()...))> - static true_type __test(int); - - template - static false_type __test(...); - }; - - template - struct __is_nary_constructible_impl - : public __do_is_nary_constructible_impl - { - typedef decltype(__test<_Tp, _Args...>(0)) type; - }; - - template - struct __is_nary_constructible - : public __is_nary_constructible_impl<_Tp, _Args...>::type - { - static_assert(sizeof...(_Args) > 1, - "Only useful for > 1 arguments"); - }; - - template - struct __is_constructible_impl - : public __is_nary_constructible<_Tp, _Args...> - { }; - - template - struct __is_constructible_impl<_Tp, _Arg> - : public __is_direct_constructible<_Tp, _Arg> - { }; - - template - struct __is_constructible_impl<_Tp> - : public is_default_constructible<_Tp> - { }; - /// is_constructible template struct is_constructible - : public __is_constructible_impl<_Tp, _Args...>::type + : public __bool_constant<__is_constructible(_Tp, _Args...)> { }; template::value> @@ -1255,26 +1052,10 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION : public __is_nothrow_move_constructible_impl<_Tp> { }; - template - class __is_assignable_helper - { - template() = declval<_Up1>())> - static true_type - __test(int); - - template - static false_type - __test(...); - - public: - typedef decltype(__test<_Tp, _Up>(0)) type; - }; - /// is_assignable template struct is_assignable - : public __is_assignable_helper<_Tp, _Up>::type + : public __bool_constant<__is_assignable(_Tp, _Up)> { }; template::value> @@ -1364,8 +1145,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION /// is_trivially_constructible template struct is_trivially_constructible - : public __and_, integral_constant> + : public __bool_constant<__is_trivially_constructible(_Tp, _Args...)> { }; /// is_trivially_default_constructible @@ -1423,9 +1203,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION /// is_trivially_assignable template struct is_trivially_assignable - : public __and_, - integral_constant> + : public __bool_constant<__is_trivially_assignable(_Tp, _Up)> { }; /// is_trivially_copy_assignable diff --git a/libstdc++-v3/testsuite/20_util/declval/requirements/1_neg.cc b/libstdc++-v3/testsuite/20_util/declval/requirements/1_neg.cc index dc9daeb..0c5599d 100644 --- a/libstdc++-v3/testsuite/20_util/declval/requirements/1_neg.cc +++ b/libstdc++-v3/testsuite/20_util/declval/requirements/1_neg.cc @@ -18,7 +18,7 @@ // with this library; see the file COPYING3. If not see // . -// { dg-error "static assertion failed" "" { target *-*-* } 2259 } +// { dg-error "static assertion failed" "" { target *-*-* } 2037 } #include diff --git a/libstdc++-v3/testsuite/20_util/make_signed/requirements/typedefs_neg.cc b/libstdc++-v3/testsuite/20_util/make_signed/requirements/typedefs_neg.cc index 664fb70..4b83764 100644 --- a/libstdc++-v3/testsuite/20_util/make_signed/requirements/typedefs_neg.cc +++ b/libstdc++-v3/testsuite/20_util/make_signed/requirements/typedefs_neg.cc @@ -47,4 +47,4 @@ void test01() // { dg-error "required from here" "" { target *-*-* } 39 } // { dg-error "required from here" "" { target *-*-* } 41 } -// { dg-error "invalid use of incomplete type" "" { target *-*-* } 1924 } +// { dg-error "invalid use of incomplete type" "" { target *-*-* } 1702 } diff --git a/libstdc++-v3/testsuite/20_util/make_unsigned/requirements/typedefs_neg.cc b/libstdc++-v3/testsuite/20_util/make_unsigned/requirements/typedefs_neg.cc index 6d64717..d77b023 100644 --- a/libstdc++-v3/testsuite/20_util/make_unsigned/requirements/typedefs_neg.cc +++ b/libstdc++-v3/testsuite/20_util/make_unsigned/requirements/typedefs_neg.cc @@ -47,5 +47,5 @@ void test01() // { dg-error "required from here" "" { target *-*-* } 39 } // { dg-error "required from here" "" { target *-*-* } 41 } -// { dg-error "invalid use of incomplete type" "" { target *-*-* } 1820 } -// { dg-error "declaration of" "" { target *-*-* } 1777 } +// { dg-error "invalid use of incomplete type" "" { target *-*-* } 1598 } +// { dg-error "declaration of" "" { target *-*-* } 1555 }