From patchwork Wed Nov 16 08:25:58 2022 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Jakub Jelinek X-Patchwork-Id: 20788 Return-Path: Delivered-To: ouuuleilei@gmail.com Received: by 2002:a5d:6687:0:0:0:0:0 with SMTP id l7csp22637wru; Wed, 16 Nov 2022 00:26:50 -0800 (PST) X-Google-Smtp-Source: AA0mqf7bVcrnMFXUeHI+dMMYznDpELvv5O3/5lG6b8jynvN8AvhIjHC9Xx/1GPjYEsi5Xn7LxsUE X-Received: by 2002:a17:906:af67:b0:774:ade6:ce3f with SMTP id os7-20020a170906af6700b00774ade6ce3fmr16889546ejb.624.1668587210321; Wed, 16 Nov 2022 00:26:50 -0800 (PST) ARC-Seal: i=1; a=rsa-sha256; t=1668587210; cv=none; d=google.com; s=arc-20160816; b=DpXf9YryhcV8c6vKjsCJ3KZKTnaS57r2Hyx9xjBXp2bUJYIqgoenOuTYbwPfJ41J5T 41zV+7oaW2UfocE0luD2EUUnGwJyCnXSB2mXo0uNmVuqb2s0xSQP4t23uETOxQYOUGwn /KouRIwrRsKAIEvVKs30OvGufi64MkiXpIk2K7PG5PfiJse/kV6FpYapDsHFWziarmsl GmofmZSe+GUFfG+7s/2gVW+F1d+B+pPHELfQndV48jC4y14eRj5joTI3dIN965lpYJSO OJZhon+YOSPIU7gOJS3eNUyqKnuTDxHTGKWx+UEF4geP4QKhUDQg0rJe86kAsH4FNWRK nZLw== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=arc-20160816; h=sender:errors-to:reply-to:from:list-subscribe:list-help:list-post :list-archive:list-unsubscribe:list-id:precedence :content-disposition:in-reply-to:mime-version:references:message-id :subject:cc:to:date:dmarc-filter:delivered-to:dkim-signature :dkim-filter; bh=PAM14C4bq8Z9ZmfdSgykYhvkZZMwUOyrUwAYBuy/Wrs=; b=kRMfWYAaUOK4a+47whL92rpoxZsWnogJjwTtPdUggf258ihHEhbagDUP1Oa7Cwfz1R zVfObrh0Hda8FLujmr11UDPbvEJKUFFea0NK4SMi+pFXOgdGZrveeNClpckjWn+xFnu/ 9SfoNPhilLtOZE4X/JioaWpv5dXG0M7eAGG8/8M3J+RkBMWaC9Du6uxlCJ2VIUCQVBsD fdgKwUmP5QzHrtkFzsYRXfVNV12wjMiC3MF4UP3Fa6zJX9JX0ZhrJtaIvMUl3EHsKycw 9fzgElB9imsImCjtLyidvA0b00zZyr7H9tsYq9teB2JWuyqK3rDtjUg2VmD+Zr9NHw4W dt8g== ARC-Authentication-Results: i=1; mx.google.com; dkim=pass header.i=@gcc.gnu.org header.s=default header.b=H51hhlsK; spf=pass (google.com: domain of gcc-patches-bounces+ouuuleilei=gmail.com@gcc.gnu.org designates 8.43.85.97 as permitted sender) smtp.mailfrom="gcc-patches-bounces+ouuuleilei=gmail.com@gcc.gnu.org"; dmarc=pass (p=NONE sp=NONE dis=NONE) header.from=gnu.org Received: from sourceware.org (server2.sourceware.org. [8.43.85.97]) by mx.google.com with ESMTPS id qw3-20020a1709066a0300b0078de83a052csi13514587ejc.483.2022.11.16.00.26.50 for (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Wed, 16 Nov 2022 00:26:50 -0800 (PST) Received-SPF: pass (google.com: domain of gcc-patches-bounces+ouuuleilei=gmail.com@gcc.gnu.org designates 8.43.85.97 as permitted sender) client-ip=8.43.85.97; Authentication-Results: mx.google.com; dkim=pass header.i=@gcc.gnu.org header.s=default header.b=H51hhlsK; spf=pass (google.com: domain of gcc-patches-bounces+ouuuleilei=gmail.com@gcc.gnu.org designates 8.43.85.97 as permitted sender) smtp.mailfrom="gcc-patches-bounces+ouuuleilei=gmail.com@gcc.gnu.org"; dmarc=pass (p=NONE sp=NONE dis=NONE) header.from=gnu.org Received: from server2.sourceware.org (localhost [IPv6:::1]) by sourceware.org (Postfix) with ESMTP id 6183B3959C4F for ; Wed, 16 Nov 2022 08:26:49 +0000 (GMT) DKIM-Filter: OpenDKIM Filter v2.11.0 sourceware.org 6183B3959C4F DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gcc.gnu.org; s=default; t=1668587209; bh=PAM14C4bq8Z9ZmfdSgykYhvkZZMwUOyrUwAYBuy/Wrs=; h=Date:To:Cc:Subject:References:In-Reply-To:List-Id: List-Unsubscribe:List-Archive:List-Post:List-Help:List-Subscribe: From:Reply-To:From; b=H51hhlsKAG04cVDxspxwwfFI/2Uakvzm3gXV0tziY2MvKfWycdnxPcf8GA6RP3QAu U33As4vXBAu5mTCaGn1LXDWjCDHpDnTWcU4LfodPp4wTVbeV7mkX/W2B836NVuJE6i Jm89VQtAzyYgExLTZaQ+4pfoqgVsdDyXCLnFasRw= X-Original-To: gcc-patches@gcc.gnu.org Delivered-To: gcc-patches@gcc.gnu.org Received: from us-smtp-delivery-124.mimecast.com (us-smtp-delivery-124.mimecast.com [170.10.129.124]) by sourceware.org (Postfix) with ESMTPS id F13613955CB9 for ; Wed, 16 Nov 2022 08:26:05 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.4.1 sourceware.org F13613955CB9 Received: from mimecast-mx02.redhat.com (mimecast-mx02.redhat.com [66.187.233.88]) by relay.mimecast.com with ESMTP with STARTTLS (version=TLSv1.2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id us-mta-661-gOm8Q1NQPcWcO1wBSewz7A-1; Wed, 16 Nov 2022 03:26:04 -0500 X-MC-Unique: gOm8Q1NQPcWcO1wBSewz7A-1 Received: from smtp.corp.redhat.com (int-mx10.intmail.prod.int.rdu2.redhat.com [10.11.54.10]) (using TLSv1.2 with cipher AECDH-AES256-SHA (256/256 bits)) (No client certificate requested) by mimecast-mx02.redhat.com (Postfix) with ESMTPS id 16E6D803D50 for ; Wed, 16 Nov 2022 08:26:04 +0000 (UTC) Received: from tucnak.zalov.cz (unknown [10.39.192.38]) by smtp.corp.redhat.com (Postfix) with ESMTPS id C7ED8492B05; Wed, 16 Nov 2022 08:26:03 +0000 (UTC) Received: from tucnak.zalov.cz (localhost [127.0.0.1]) by tucnak.zalov.cz (8.17.1/8.17.1) with ESMTPS id 2AG8PxhG2449064 (version=TLSv1.3 cipher=TLS_AES_256_GCM_SHA384 bits=256 verify=NOT); Wed, 16 Nov 2022 09:25:59 +0100 Received: (from jakub@localhost) by tucnak.zalov.cz (8.17.1/8.17.1/Submit) id 2AG8Pw6e2449063; Wed, 16 Nov 2022 09:25:58 +0100 Date: Wed, 16 Nov 2022 09:25:58 +0100 To: Jason Merrill Cc: gcc-patches@gcc.gnu.org Subject: [PATCH] c++, v2: Fix up calls to static operator() or operator[] [PR107624] Message-ID: References: <1ec099de-4247-29ec-0e06-602a90370388@redhat.com> <3a734cad-3036-8429-adc5-a663a4fc7c7d@redhat.com> MIME-Version: 1.0 In-Reply-To: <3a734cad-3036-8429-adc5-a663a4fc7c7d@redhat.com> X-Scanned-By: MIMEDefang 3.1 on 10.11.54.10 X-Mimecast-Spam-Score: 0 X-Mimecast-Originator: redhat.com Content-Disposition: inline X-Spam-Status: No, score=-3.5 required=5.0 tests=BAYES_00, DKIMWL_WL_HIGH, DKIM_SIGNED, DKIM_VALID, DKIM_VALID_AU, DKIM_VALID_EF, RCVD_IN_DNSWL_NONE, RCVD_IN_MSPIKE_H2, SPF_HELO_NONE, SPF_NONE, TXREP autolearn=ham autolearn_force=no version=3.4.6 X-Spam-Checker-Version: SpamAssassin 3.4.6 (2021-04-09) on server2.sourceware.org X-BeenThere: gcc-patches@gcc.gnu.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: Gcc-patches mailing list List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , X-Patchwork-Original-From: Jakub Jelinek via Gcc-patches From: Jakub Jelinek Reply-To: Jakub Jelinek Errors-To: gcc-patches-bounces+ouuuleilei=gmail.com@gcc.gnu.org Sender: "Gcc-patches" X-getmail-retrieved-from-mailbox: =?utf-8?q?INBOX?= X-GMAIL-THRID: =?utf-8?q?1749640503036409192?= X-GMAIL-MSGID: =?utf-8?q?1749640503036409192?= On Tue, Nov 15, 2022 at 04:49:27PM -0500, Jason Merrill wrote: > > Or do you want to outline the > > if (result != error_mark_node > > && TREE_CODE (TREE_TYPE (cand->fn)) != METHOD_TYPE > > && TREE_SIDE_EFFECTS (obj)) > > { > > /* But avoid the implicit lvalue-rvalue conversion when 'a' > > is volatile. */ > > tree a = obj; > > if (TREE_THIS_VOLATILE (a)) > > a = build_this (a); > > if (TREE_SIDE_EFFECTS (a)) > > result = build2 (COMPOUND_EXPR, TREE_TYPE (result), a, result); > > } > > part that is now repeated 4 times to some helper function? If yes, > > any suggestion on a good name? > > Please. Maybe keep_unused_object_arg? So like this? Bootstrapped/regtested on x86_64-linux and i686-linux, ok for trunk? 2022-11-16 Jakub Jelinek PR c++/107624 * call.cc (keep_unused_object_arg): New function. (build_op_call): Use it. (build_op_subscript): Likewise. (build_new_op): Similarly for ARRAY_REF. (build_new_method_call): Likewise. * decl.cc (grok_op_properties): For C++20 and earlier, if operator[] is static member function, require exactly one parameter rather than exactly two parameters. * g++.dg/cpp23/static-operator-call4.C: New test. * g++.dg/cpp23/subscript10.C: New test. * g++.dg/cpp23/subscript11.C: New test. Jakub --- gcc/cp/call.cc.jj 2022-11-15 07:59:57.337231337 +0100 +++ gcc/cp/call.cc 2022-11-15 23:10:14.077666314 +0100 @@ -5017,6 +5017,33 @@ build_operator_new_call (tree fnname, ve return ret; } +/* Evaluate side-effects from OBJ before evaluating call + to FN in RESULT expression. + This is for expressions of the form `obj->fn(...)' + where `fn' turns out to be a static member function and + `obj' needs to be evaluated. `fn' could be also static operator[] + or static operator(), in which cases the source expression + would be `obj[...]' or `obj(...)'. */ + +static tree +keep_unused_object_arg (tree result, tree obj, tree fn) +{ + if (result == NULL_TREE + || result == error_mark_node + || TREE_CODE (TREE_TYPE (fn)) == METHOD_TYPE + || !TREE_SIDE_EFFECTS (obj)) + return result; + + /* But avoid the implicit lvalue-rvalue conversion when `obj' is + volatile. */ + tree a = obj; + if (TREE_THIS_VOLATILE (a)) + a = build_this (a); + if (TREE_SIDE_EFFECTS (a)) + return build2 (COMPOUND_EXPR, TREE_TYPE (result), a, result); + return result; +} + /* Build a new call to operator(). This may change ARGS. */ tree @@ -5137,7 +5164,13 @@ build_op_call (tree obj, vecfn) == FUNCTION_DECL && DECL_OVERLOADED_OPERATOR_P (cand->fn) && DECL_OVERLOADED_OPERATOR_IS (cand->fn, CALL_EXPR)) - result = build_over_call (cand, LOOKUP_NORMAL, complain); + { + result = build_over_call (cand, LOOKUP_NORMAL, complain); + /* In an expression of the form `a()' where cand->fn + which is operator() turns out to be a static member function, + `a' is none-the-less evaluated. */ + result = keep_unused_object_arg (result, obj, cand->fn); + } else { if (TREE_CODE (cand->fn) == FUNCTION_DECL) @@ -7046,6 +7079,12 @@ build_new_op (const op_location_t &loc, gcc_unreachable (); } } + + /* In an expression of the form `a[]' where cand->fn + which is operator[] turns out to be a static member function, + `a' is none-the-less evaluated. */ + if (code == ARRAY_REF) + result = keep_unused_object_arg (result, arg1, cand->fn); } else { @@ -7302,6 +7341,11 @@ build_op_subscript (const op_location_t /* Specify evaluation order as per P0145R2. */ CALL_EXPR_ORDERED_ARGS (call) = op_is_ordered (ARRAY_REF) == 1; } + + /* In an expression of the form `a[]' where cand->fn + which is operator[] turns out to be a static member function, + `a' is none-the-less evaluated. */ + result = keep_unused_object_arg (result, obj, cand->fn); } else gcc_unreachable (); @@ -11494,21 +11538,11 @@ build_new_method_call (tree instance, tr /* In an expression of the form `a->f()' where `f' turns out to be a static member function, `a' is none-the-less evaluated. */ - if (TREE_CODE (TREE_TYPE (fn)) != METHOD_TYPE - && !is_dummy_object (instance) - && TREE_SIDE_EFFECTS (instance)) - { - /* But avoid the implicit lvalue-rvalue conversion when 'a' - is volatile. */ - tree a = instance; - if (TREE_THIS_VOLATILE (a)) - a = build_this (a); - if (TREE_SIDE_EFFECTS (a)) - call = build2 (COMPOUND_EXPR, TREE_TYPE (call), a, call); - } - else if (call != error_mark_node - && DECL_DESTRUCTOR_P (cand->fn) - && !VOID_TYPE_P (TREE_TYPE (call))) + if (!is_dummy_object (instance)) + call = keep_unused_object_arg (call, instance, fn); + if (call != error_mark_node + && DECL_DESTRUCTOR_P (cand->fn) + && !VOID_TYPE_P (TREE_TYPE (call))) /* An explicit call of the form "x->~X()" has type "void". However, on platforms where destructors return "this" (i.e., those where --- gcc/cp/decl.cc.jj 2022-11-15 07:59:57.321231551 +0100 +++ gcc/cp/decl.cc 2022-11-15 13:13:51.814356965 +0100 @@ -15400,6 +15400,10 @@ grok_op_properties (tree decl, bool comp pedwarn (loc, OPT_Wc__23_extensions, "%qD may be a static member " "function only with %<-std=c++23%> or %<-std=gnu++23%>", decl); + if (operator_code == ARRAY_REF) + /* static operator[] should have exactly one argument + for C++20 and earlier, so that it isn't multidimensional. */ + op_flags = OVL_OP_FLAG_UNARY; } else if (DECL_STATIC_FUNCTION_P (decl)) { --- gcc/testsuite/g++.dg/cpp23/static-operator-call4.C.jj 2022-11-15 11:26:28.187511136 +0100 +++ gcc/testsuite/g++.dg/cpp23/static-operator-call4.C 2022-11-15 11:27:19.684814244 +0100 @@ -0,0 +1,37 @@ +// PR c++/107624 +// { dg-do run { target c++11 } } +// { dg-options "" } + +int n[3]; +struct S { + static void operator() (int x) { n[0] |= (1 << x); } // { dg-warning "may be a static member function only with" "" { target c++20_down } } + static void baz (int x) { n[1] |= (1 << x); } + int s; +}; +volatile S s[2]; + +S & +foo (int x) +{ + static S t; + n[2] |= (1 << x); + return t; +} + +int +main () +{ + int i = 0; + foo (0) (0); + if (n[0] != 1 || n[1] || n[2] != 1) + __builtin_abort (); + foo (1).baz (1); + if (n[0] != 1 || n[1] != 2 || n[2] != 3) + __builtin_abort (); + s[i++] (2); + if (i != 1 || n[0] != 5 || n[1] != 2 || n[2] != 3) + __builtin_abort (); + s[--i].baz (3); + if (i != 0 || n[0] != 5 || n[1] != 10 || n[2] != 3) + __builtin_abort (); +} --- gcc/testsuite/g++.dg/cpp23/subscript10.C.jj 2022-11-15 11:27:48.810420112 +0100 +++ gcc/testsuite/g++.dg/cpp23/subscript10.C 2022-11-15 13:07:02.974885454 +0100 @@ -0,0 +1,46 @@ +// PR c++/107624 +// { dg-do run { target c++11 } } +// { dg-options "" } + +int n[3]; +struct S { + static int &operator[] (int x) { n[0] |= (1 << x); return n[2]; } // { dg-warning "may be a static member function only with" "" { target c++20_down } } +#if __cpp_multidimensional_subscript >= 202211L + static int &operator[] () { n[0] |= (1 << 8); return n[2]; } + static int &operator[] (int y, int z, int w) { n[0] |= (1 << y) | (1 << z) | (1 << w); return n[2]; } +#endif + int s; +}; +volatile S s[2]; + +S & +foo (int x) +{ + static S t; + n[1] |= (1 << x); + return t; +} + +int +main () +{ + int i = 0; + foo (0) [0]++; + if (n[0] != 1 || n[1] != 1 || n[2] != 1) + __builtin_abort (); + s[i++][2]++; + if (i != 1 || n[0] != 5 || n[1] != 1 || n[2] != 2) + __builtin_abort (); +#if __cpp_multidimensional_subscript >= 202211L + foo (3) []++; + if (n[0] != 261 || n[1] != 9 || n[2] != 3) + __builtin_abort (); + int y = 10; + int z = 10; + int w = 13; + foo (4) [y++, ++z, w++]++; + if (n[0] != 11525 || n[1] != 25 || n[2] != 4 + || y != 11 || z != 11 || w != 14) + __builtin_abort (); +#endif +} --- gcc/testsuite/g++.dg/cpp23/subscript11.C.jj 2022-11-15 13:14:50.938557460 +0100 +++ gcc/testsuite/g++.dg/cpp23/subscript11.C 2022-11-15 13:19:20.681910074 +0100 @@ -0,0 +1,11 @@ +// { dg-do compile { target c++11 } } +// { dg-options "" } + +struct S { + static int &operator[] (int); // { dg-warning "may be a static member function only with" "" { target c++20_down } } + static int &operator[] (); // { dg-warning "may be a static member function only with" "" { target c++20_down } } + // { dg-error "'static int& S::operator\\\[\\\]\\\(\\\)' must have exactly one argument" "" { target c++20_down } .-1 } + static int &operator[] (int, int, int); // { dg-warning "may be a static member function only with" "" { target c++20_down } } + // { dg-error "'static int& S::operator\\\[\\\]\\\(int, int, int\\\)' must have exactly one argument" "" { target c++20_down } .-1 } + int s; +};