From patchwork Fri Mar 1 00:12:19 2024 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Marek Polacek X-Patchwork-Id: 208569 Return-Path: Delivered-To: ouuuleilei@gmail.com Received: by 2002:a05:7301:2097:b0:108:e6aa:91d0 with SMTP id gs23csp762331dyb; Thu, 29 Feb 2024 16:13:29 -0800 (PST) X-Forwarded-Encrypted: i=3; AJvYcCXW32/9Uok+KhLvB9KOHM7AWjIX5niXB25hwdWqgahViBB6J9JJtEzJlncHJkZeTjEzmSMdDQ9Y9AvbN3ASTmC25gcM4Q== X-Google-Smtp-Source: AGHT+IFYF96XjKzBuOATEmLJhzEbeSpTZN4ZVbLZHZP0oIHWUpm/dyd8/1tyisu5YiRcbH0UZKQT X-Received: by 2002:a05:620a:1265:b0:787:d4d7:1a72 with SMTP id b5-20020a05620a126500b00787d4d71a72mr188239qkl.46.1709252008847; Thu, 29 Feb 2024 16:13:28 -0800 (PST) ARC-Seal: i=2; a=rsa-sha256; t=1709252008; cv=pass; d=google.com; s=arc-20160816; b=PHPMU3t8nhVpm9/wJZkkzfX7pPd/bLc/OJACFGQVnBFk4Z72XlgwDZ3foaOofzOZ4w b1PFoMjt7Ey+VCUGErnZkk6GSKwf36Bf7cvSYdBZwr787ES7FTjaonYBd+yiQLEEZ1hE p2Ig+LUUoo3COmokSogx9zO1x6Yio1Mq0q4Dkc4EeOmORZTYHvt/EpL8CaETfaHVwjn1 hFEuQZfRrNEltPVMyvT9j04K9MTodb61lkmXkg7O2V6g+DQa4ZF5F98a3aJrZbJvOt73 xv9gbHtKpp3MvhqDxGKpdxU3inwLEMFn+0NUpoxxVKo+z/h315yqSMZAlKsKVyiWoLfD AWyg== ARC-Message-Signature: i=2; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=arc-20160816; h=errors-to:list-subscribe:list-help:list-post:list-archive :list-unsubscribe:list-id:precedence:content-disposition:user-agent :in-reply-to:mime-version:references:message-id:subject:cc:to:from :date:dkim-signature:arc-filter:dmarc-filter:delivered-to; bh=0ynkJekoy9Mdc6qxrbRICH+NJFX1aRZ67ZTzn0FbaWQ=; fh=rsfJLMIL/7j+58qzkgIXBlfQSah3iXypQc76SN5PqTs=; b=TsUgfychWIm1lr6C0t4c2j+auKEm06lfphyHixiS/5LrA2aDDCiS5wjZl1UrlF9V3O QlEpPi3BtMSPMSLR1L4DzetVqSYMf3Cr55y9ygA8EmZgA9W3aC/Oe9R6E2f1nwZkSJMy Vf2ePEQpjn3UndLxaxhFpm0oo67vdZDGUwHI+FWAMrBj9SHRpllOJqxF1UsntWgtmMeb XuOEwFI6pL67EsOONisRZiotMogvVs3SfrIxQfnrrULhkysfr+dBh5eSSXN8Q+4xMbDG +DE2b+oAJITYYe8cYna5zmT/keVnAnRpez86Gb156+0lfUfWhW/HiKXU15q8Q9djLjvb JXKQ==; dara=google.com ARC-Authentication-Results: i=2; mx.google.com; dkim=pass header.i=@redhat.com header.s=mimecast20190719 header.b=Z8L3TKPP; arc=pass (i=1); spf=pass (google.com: domain of gcc-patches-bounces+ouuuleilei=gmail.com@gcc.gnu.org designates 2620:52:3:1:0:246e:9693:128c as permitted sender) smtp.mailfrom="gcc-patches-bounces+ouuuleilei=gmail.com@gcc.gnu.org"; dmarc=pass (p=NONE sp=NONE dis=NONE) header.from=redhat.com Received: from server2.sourceware.org (server2.sourceware.org. [2620:52:3:1:0:246e:9693:128c]) by mx.google.com with ESMTPS id bk27-20020a05620a1a1b00b00787b7fb88b9si2799886qkb.630.2024.02.29.16.13.28 for (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Thu, 29 Feb 2024 16:13:28 -0800 (PST) Received-SPF: pass (google.com: domain of gcc-patches-bounces+ouuuleilei=gmail.com@gcc.gnu.org designates 2620:52:3:1:0:246e:9693:128c as permitted sender) client-ip=2620:52:3:1:0:246e:9693:128c; Authentication-Results: mx.google.com; dkim=pass header.i=@redhat.com header.s=mimecast20190719 header.b=Z8L3TKPP; arc=pass (i=1); spf=pass (google.com: domain of gcc-patches-bounces+ouuuleilei=gmail.com@gcc.gnu.org designates 2620:52:3:1:0:246e:9693:128c as permitted sender) smtp.mailfrom="gcc-patches-bounces+ouuuleilei=gmail.com@gcc.gnu.org"; dmarc=pass (p=NONE sp=NONE dis=NONE) header.from=redhat.com Received: from server2.sourceware.org (localhost [IPv6:::1]) by sourceware.org (Postfix) with ESMTP id 7F8EA3858408 for ; Fri, 1 Mar 2024 00:13:28 +0000 (GMT) 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 1E9883858C5F for ; Fri, 1 Mar 2024 00:12:25 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.4.2 sourceware.org 1E9883858C5F Authentication-Results: sourceware.org; dmarc=pass (p=none dis=none) header.from=redhat.com Authentication-Results: sourceware.org; spf=pass smtp.mailfrom=redhat.com ARC-Filter: OpenARC Filter v1.0.0 sourceware.org 1E9883858C5F Authentication-Results: server2.sourceware.org; arc=none smtp.remote-ip=170.10.129.124 ARC-Seal: i=1; a=rsa-sha256; d=sourceware.org; s=key; t=1709251950; cv=none; b=myxzicZXUaaxPiYz9N7+1ZPtl4LhKRafWfYvIdr64NHywa49MKBWIELWPu6/eDsXQ+tI9Glp+2f/W5oB0FGYMYwVv9giSr5bwvhp+h2eGQYUV9Nw9oGglso8lDmEC4wfXkrIIWS6pN2tScoLnEuvfI3irYEToN4LbVVkqAzT94o= ARC-Message-Signature: i=1; a=rsa-sha256; d=sourceware.org; s=key; t=1709251950; c=relaxed/simple; bh=q2rSLxOMTB+FHUOp4Gb1NjysDaKbZDL1gyiiIAJNocA=; h=DKIM-Signature:Date:From:To:Subject:Message-ID:MIME-Version; b=gDP7J7SHWzxD9ekJqqa//XItFAut9/LalOt6VnyR0srekdtm9pMYVICKS3TQXIFLqA46SDrVR0LUOaS5lAiAn+99lZRKaPgcyq/VtS5Zp9aACqH4FRsUXIFTGH3lpKgHaccHLXLllrBH7iPhnP2ZKOGV3fn9lwGMg9/gkE9mgqU= ARC-Authentication-Results: i=1; server2.sourceware.org DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=redhat.com; s=mimecast20190719; t=1709251945; h=from:from:reply-to:subject:subject:date:date:message-id:message-id: to:to:cc:cc:mime-version:mime-version:content-type:content-type: in-reply-to:in-reply-to:references:references; bh=0ynkJekoy9Mdc6qxrbRICH+NJFX1aRZ67ZTzn0FbaWQ=; b=Z8L3TKPPw2R9DcW/0EnK52LfmAKAKpzS1ZG8QWbTQMmesdGLU7Wp6J5fvHlMhU5I6YSj8D f0qCNmC7iYytVB8ZnciFxIcg2VRnG165w6uY0epG/SI4eXP+4Wv506gbjggI66SMZPzDNo al9+DVuR3KCMwvHKSnOuyz9N8vh/7WM= Received: from mail-qv1-f70.google.com (mail-qv1-f70.google.com [209.85.219.70]) by relay.mimecast.com with ESMTP with STARTTLS (version=TLSv1.3, cipher=TLS_AES_256_GCM_SHA384) id us-mta-379-0JOvVjlKNPy_VUMWUq4CDA-1; Thu, 29 Feb 2024 19:12:23 -0500 X-MC-Unique: 0JOvVjlKNPy_VUMWUq4CDA-1 Received: by mail-qv1-f70.google.com with SMTP id 6a1803df08f44-690316dcdb3so14266576d6.0 for ; Thu, 29 Feb 2024 16:12:23 -0800 (PST) X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1709251943; x=1709856743; h=user-agent:in-reply-to:content-disposition:mime-version:references :message-id:subject:cc:to:from:date:x-gm-message-state:from:to:cc :subject:date:message-id:reply-to; bh=0ynkJekoy9Mdc6qxrbRICH+NJFX1aRZ67ZTzn0FbaWQ=; b=YzOSxe0C8vvoLbtkv1oVfmv1XRwfX3BP8kyBtP4/wtjDx5xxLECqARD7PopMeOMWbm dwP1R6lkkDrYwIVrFeY4ufxhK4TiIsiExYmz9WfD++DTJK77jkUqoEo0nJYNrNIJxk0W 85h5pPZZ14BbHwr7WmGjmj2vOaChBijIpdEUO4rAfVObyNpxSZBSsPhiW1LdQ08xidZ1 yaqh0mYwteFAO9OkY3kb9jETVd54jyWBJkwbvIa/iMhwGBs4vn+jPLuhDsy/O2EfTVo5 vyuN4TytiPRApAEvuAuJ96XXtXrfZK1VrMQJIlIYLm8EbSyCXVz20pb6tLT+ky11t6/x Lbbg== X-Gm-Message-State: AOJu0YyMY4Kg7nypqCUzjGZXSFyAJ9bn344Eq+nuPERPjseK9FWx5HlX op+kI4QTLs1e6WJ1gImizVkIycmdG2oKTg1goiVnIneaonjeHMOjYt4TTyTLksWuQtyTt/aieoO v9S6UqjYyUTFH9nR9DW2eLbRGwFC4CKBDz5G5GkFT11hJlVpEF7b2sDc24cM6gJI= X-Received: by 2002:ad4:4b70:0:b0:690:4d5f:49a with SMTP id m16-20020ad44b70000000b006904d5f049amr172496qvx.8.1709251942640; Thu, 29 Feb 2024 16:12:22 -0800 (PST) X-Received: by 2002:ad4:4b70:0:b0:690:4d5f:49a with SMTP id m16-20020ad44b70000000b006904d5f049amr172465qvx.8.1709251941963; Thu, 29 Feb 2024 16:12:21 -0800 (PST) Received: from redhat.com (2603-7000-9500-34a5-0000-0000-0000-1db4.res6.spectrum.com. [2603:7000:9500:34a5::1db4]) by smtp.gmail.com with ESMTPSA id c11-20020a056214070b00b0068f8927ac6fsm1261169qvz.66.2024.02.29.16.12.21 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Thu, 29 Feb 2024 16:12:21 -0800 (PST) Date: Thu, 29 Feb 2024 19:12:19 -0500 From: Marek Polacek To: Jason Merrill Cc: GCC Patches Subject: [PATCH v3] c++: implement [[gnu::non_owning]] [PR110358] Message-ID: References: <20240126013736.70125-1-polacek@redhat.com> <0e4c47b6-604c-4d30-b458-825959c0e1d6@redhat.com> MIME-Version: 1.0 In-Reply-To: User-Agent: Mutt/2.2.12 (2023-09-09) X-Mimecast-Spam-Score: 0 X-Mimecast-Originator: redhat.com Content-Disposition: inline X-Spam-Status: No, score=-12.3 required=5.0 tests=BAYES_00, DKIMWL_WL_HIGH, DKIM_SIGNED, DKIM_VALID, DKIM_VALID_AU, DKIM_VALID_EF, GIT_PATCH_0, RCVD_IN_DNSWL_NONE, RCVD_IN_MSPIKE_H2, SPF_HELO_NONE, SPF_NONE, TXREP, T_SCC_BODY_TEXT_LINE 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.30 Precedence: list List-Id: Gcc-patches mailing list List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: gcc-patches-bounces+ouuuleilei=gmail.com@gcc.gnu.org X-getmail-retrieved-from-mailbox: INBOX X-GMAIL-THRID: 1789115088088171040 X-GMAIL-MSGID: 1792280634355271700 On Wed, Feb 28, 2024 at 06:03:54PM -0500, Jason Merrill wrote: > On 2/21/24 19:35, Marek Polacek wrote: > > On Fri, Jan 26, 2024 at 04:04:35PM -0500, Jason Merrill wrote: > > > On 1/25/24 20:37, Marek Polacek wrote: > > > > Bootstrapped/regtested on x86_64-pc-linux-gnu, ok for trunk? > > > > > > > > -- >8 -- > > > > Since -Wdangling-reference has false positives that can't be > > > > prevented, we should offer an easy way to suppress the warning. > > > > Currently, that is only possible by using a #pragma, either around the > > > > enclosing class or around the call site. But #pragma GCC diagnostic tend > > > > to be onerous. A better solution would be to have an attribute. Such > > > > an attribute should not be tied to this particular warning though. [*] > > > > > > > > The warning bogusly triggers for classes that are like std::span, > > > > std::reference_wrapper, and std::ranges::ref_view. The common property > > > > seems to be that these classes are only wrappers around some data. So > > > > I chose the name non_owning, but I'm not attached to it. I hope that > > > > in the future the attribute can be used for something other than this > > > > diagnostic. > > > > > > You decided not to pursue Barry's request for a bool argument to the > > > attribute? > > > > At first I thought it'd be an unnecessary complication but it was actually > > pretty easy. Better to accept the optional argument from the get-go > > otherwise people would have to add > GCC 14 checks. > > > Might it be more useful for the attribute to make reference_like_class_p > > > return true, so that we still warn about a temporary of another type passing > > > through it? > > > > Good point. Fixed. > > > > Bootstrapped/regtested on x86_64-pc-linux-gnu, ok for trunk? > > > > -- >8 -- > > Since -Wdangling-reference has false positives that can't be > > prevented, we should offer an easy way to suppress the warning. > > Currently, that is only possible by using a #pragma, either around the > > enclosing class or around the call site. But #pragma GCC diagnostic tend > > to be onerous. A better solution would be to have an attribute. Such > > an attribute should not be tied to this particular warning though. > > > > The warning bogusly triggers for classes that are like std::span, > > std::reference_wrapper, and std::ranges::ref_view. The common property > > seems to be that these classes are only wrappers around some data. So > > I chose the name non_owning, but I'm not attached to it. I hope that > > in the future the attribute can be used for something other than this > > diagnostic. > > > > This attribute takes an optional bool argument to support cases like: > > > > template > > struct [[gnu::non_owning(std::is_reference_v)]] S { > > // ... > > }; > > > > PR c++/110358 > > PR c++/109642 > > > > gcc/cp/ChangeLog: > > > > * call.cc (non_owning_p): New. > > (reference_like_class_p): Use it. > > (do_warn_dangling_reference): Use it. Don't warn when the function > > or its enclosing class has attribute gnu::non_owning. > > * tree.cc (cxx_gnu_attributes): Add gnu::non_owning. > > (handle_non_owning_attribute): New. > > > > gcc/ChangeLog: > > > > * doc/extend.texi: Document gnu::non_owning. > > * doc/invoke.texi: Mention that gnu::non_owning disables > > -Wdangling-reference. > > > > gcc/testsuite/ChangeLog: > > > > * g++.dg/ext/attr-non-owning1.C: New test. > > * g++.dg/ext/attr-non-owning2.C: New test. > > * g++.dg/ext/attr-non-owning3.C: New test. > > * g++.dg/ext/attr-non-owning4.C: New test. > > * g++.dg/ext/attr-non-owning5.C: New test. > > * g++.dg/ext/attr-non-owning6.C: New test. > > * g++.dg/ext/attr-non-owning7.C: New test. > > * g++.dg/ext/attr-non-owning8.C: New test. > > * g++.dg/ext/attr-non-owning9.C: New test. > > --- > > gcc/cp/call.cc | 38 ++++++++++-- > > gcc/cp/tree.cc | 26 +++++++++ > > gcc/doc/extend.texi | 25 ++++++++ > > gcc/doc/invoke.texi | 21 +++++++ > > gcc/testsuite/g++.dg/ext/attr-non-owning1.C | 38 ++++++++++++ > > gcc/testsuite/g++.dg/ext/attr-non-owning2.C | 29 +++++++++ > > gcc/testsuite/g++.dg/ext/attr-non-owning3.C | 24 ++++++++ > > gcc/testsuite/g++.dg/ext/attr-non-owning4.C | 14 +++++ > > gcc/testsuite/g++.dg/ext/attr-non-owning5.C | 31 ++++++++++ > > gcc/testsuite/g++.dg/ext/attr-non-owning6.C | 65 +++++++++++++++++++++ > > gcc/testsuite/g++.dg/ext/attr-non-owning7.C | 31 ++++++++++ > > gcc/testsuite/g++.dg/ext/attr-non-owning8.C | 30 ++++++++++ > > gcc/testsuite/g++.dg/ext/attr-non-owning9.C | 25 ++++++++ > > 13 files changed, 391 insertions(+), 6 deletions(-) > > create mode 100644 gcc/testsuite/g++.dg/ext/attr-non-owning1.C > > create mode 100644 gcc/testsuite/g++.dg/ext/attr-non-owning2.C > > create mode 100644 gcc/testsuite/g++.dg/ext/attr-non-owning3.C > > create mode 100644 gcc/testsuite/g++.dg/ext/attr-non-owning4.C > > create mode 100644 gcc/testsuite/g++.dg/ext/attr-non-owning5.C > > create mode 100644 gcc/testsuite/g++.dg/ext/attr-non-owning6.C > > create mode 100644 gcc/testsuite/g++.dg/ext/attr-non-owning7.C > > create mode 100644 gcc/testsuite/g++.dg/ext/attr-non-owning8.C > > create mode 100644 gcc/testsuite/g++.dg/ext/attr-non-owning9.C > > > > diff --git a/gcc/cp/call.cc b/gcc/cp/call.cc > > index 1dac1470d3b..e4bf9c963bd 100644 > > --- a/gcc/cp/call.cc > > +++ b/gcc/cp/call.cc > > @@ -14033,11 +14033,7 @@ std_pair_ref_ref_p (tree t) > > return true; > > } > > -/* Return true if a class CTYPE is either std::reference_wrapper or > > - std::ref_view, or a reference wrapper class. We consider a class > > - a reference wrapper class if it has a reference member. We no > > - longer check that it has a constructor taking the same reference type > > - since that approach still generated too many false positives. */ > > +/* Return true if a class T has a reference member. */ > > static bool > > class_has_reference_member_p (tree t) > > @@ -14061,12 +14057,41 @@ class_has_reference_member_p_r (tree binfo, void *) > > ? integer_one_node : NULL_TREE); > > } > > + > > +/* Return true if T (either a class or a function) has been marked as > > + non-owning. */ > > + > > +static bool > > +non_owning_p (tree t) > > +{ > > + t = lookup_attribute ("non_owning", TYPE_ATTRIBUTES (t)); > > + if (!t) > > + return false; > > + > > + t = TREE_VALUE (t); > > + if (!t) > > + return true; > > + > > + t = build_converted_constant_bool_expr (TREE_VALUE (t), tf_warning_or_error); > > + t = cxx_constant_value (t); > > + return t == boolean_true_node; > > +} > > + > > +/* Return true if a class CTYPE is either std::reference_wrapper or > > + std::ref_view, or a reference wrapper class. We consider a class > > + a reference wrapper class if it has a reference member. We no > > + longer check that it has a constructor taking the same reference type > > + since that approach still generated too many false positives. */ > > + > > static bool > > reference_like_class_p (tree ctype) > > { > > if (!CLASS_TYPE_P (ctype)) > > return false; > > + if (non_owning_p (ctype)) > > + return true; > > + > > /* Also accept a std::pair. */ > > if (std_pair_ref_ref_p (ctype)) > > return true; > > @@ -14173,7 +14198,8 @@ do_warn_dangling_reference (tree expr, bool arg_p) > > but probably not to one of its arguments. */ > > || (DECL_OBJECT_MEMBER_FUNCTION_P (fndecl) > > && DECL_OVERLOADED_OPERATOR_P (fndecl) > > - && DECL_OVERLOADED_OPERATOR_IS (fndecl, INDIRECT_REF))) > > + && DECL_OVERLOADED_OPERATOR_IS (fndecl, INDIRECT_REF)) > > + || non_owning_p (TREE_TYPE (fndecl))) > > return NULL_TREE; > > tree rettype = TREE_TYPE (TREE_TYPE (fndecl)); > > diff --git a/gcc/cp/tree.cc b/gcc/cp/tree.cc > > index ad312710f68..017da7e294a 100644 > > --- a/gcc/cp/tree.cc > > +++ b/gcc/cp/tree.cc > > @@ -47,6 +47,7 @@ static tree verify_stmt_tree_r (tree *, int *, void *); > > static tree handle_init_priority_attribute (tree *, tree, tree, int, bool *); > > static tree handle_abi_tag_attribute (tree *, tree, tree, int, bool *); > > static tree handle_contract_attribute (tree *, tree, tree, int, bool *); > > +static tree handle_non_owning_attribute (tree *, tree, tree, int, bool *); > > /* If REF is an lvalue, returns the kind of lvalue that REF is. > > Otherwise, returns clk_none. */ > > @@ -5102,6 +5103,8 @@ static const attribute_spec cxx_gnu_attributes[] = > > handle_init_priority_attribute, NULL }, > > { "abi_tag", 1, -1, false, false, false, true, > > handle_abi_tag_attribute, NULL }, > > + { "non_owning", 0, 1, false, true, false, false, > > + handle_non_owning_attribute, NULL }, > > }; > > const scoped_attribute_specs cxx_gnu_attribute_table = > > @@ -5391,6 +5394,29 @@ handle_contract_attribute (tree *ARG_UNUSED (node), tree ARG_UNUSED (name), > > return NULL_TREE; > > } > > +/* Handle a "non_owning" attribute; arguments as in > > + struct attribute_spec.handler. */ > > + > > +tree > > +handle_non_owning_attribute (tree *node, tree name, tree args, int, > > + bool *no_add_attrs) > > +{ > > + if (args && TREE_CODE (TREE_VALUE (args)) == STRING_CST) > > + { > > + error ("%qE attribute argument must be an expression that evaluates " > > + "to true or false", name); > > + *no_add_attrs = true; > > + } > > + else if (!FUNC_OR_METHOD_TYPE_P (*node) > > + && !RECORD_OR_UNION_TYPE_P (*node)) > > + { > > + warning (OPT_Wattributes, "%qE attribute ignored", name); > > + *no_add_attrs = true; > > + } > > + > > + return NULL_TREE; > > +} > > + > > /* Return a new PTRMEM_CST of the indicated TYPE. The MEMBER is the > > thing pointed to by the constant. */ > > diff --git a/gcc/doc/extend.texi b/gcc/doc/extend.texi > > index 2135dfde9c8..9132add8267 100644 > > --- a/gcc/doc/extend.texi > > +++ b/gcc/doc/extend.texi > > @@ -29320,6 +29320,31 @@ Some_Class B __attribute__ ((init_priority (543))); > > Note that the particular values of @var{priority} do not matter; only their > > relative ordering. > > +@cindex @code{non_owning} type attribute > > +@item non_owning > > + > > +This attribute can be applied on a class type, function, or member > > +function and indicates that it does not own its associated data. For > > +example, classes like @code{std::span} or @code{std::reference_wrapper} > > +are considered non-owning. > > + > > +@smallexample > > +class [[gnu::non_owning]] S @{ @dots{} @}; > > +@end smallexample > > + > > +This attribute takes an optional argument, which must be an expression that > > +evaluates to true or false: > > + > > +@smallexample > > +template > > +struct [[gnu::non_owning(std::is_reference_v)]] S @{ > > + @dots{} > > +@}; > > +@end smallexample > > + > > +Currently, the only effect this attribute has is to suppress the > > +@option{-Wdangling-reference} diagnostic. > > + > > @cindex @code{warn_unused} type attribute > > @item warn_unused > > diff --git a/gcc/doc/invoke.texi b/gcc/doc/invoke.texi > > index b4e4ee9fb81..0df2e2ded34 100644 > > --- a/gcc/doc/invoke.texi > > +++ b/gcc/doc/invoke.texi > > @@ -3908,6 +3908,9 @@ const T& foo (const T&) @{ @dots{} @} > > #pragma GCC diagnostic pop > > @end smallexample > > +The @code{#pragma} can also surround the class; in that case, the warning > > +will be disabled for all the member functions. > > + > > @option{-Wdangling-reference} also warns about code like > > @smallexample > > @@ -3932,6 +3935,24 @@ struct Span @{ > > as @code{std::span}-like; that is, the class is a non-union class > > that has a pointer data member and a trivial destructor. > > +The warning can be disabled by using the @code{gnu::non_owning} attribute, > > +which can be applied on the enclosing class type (in which case it disables > > +the warning for all its member functions), member function, or a regular > > +function. For example: > > Hmm, if we're also going to allow the attribute to be applied to a function, > the name doesn't make so much sense. For a class, it says that the class > refers to its initializer; for a function, it says that the function return > value *doesn't* refer to its argument. Yeah, that's a fair point; I guess "non_owning" would be too perplexing. > If we want something that can apply to both classes and functions, we're > probably back to an attribute that just suppresses the warning, with a > different name. > > Or I guess we could have two attributes, but that seems like a lot. > > WDYT? I think we don't want two separate attributes, and we do want that one attribute to apply to both fns and classes. We could implement something like [[gnu::no_warning("Wdangling-reference")]] [[gnu::no_warning("Wdangling-reference", bool)]] but first, that's a lot of typing, second, it would be confusing because it wouldn't work for any other warning. We already have [[unused]] and [[maybe_unused]] whose effect is to suppress a warning. It think our best bet is to do the most straightforward thing: [[gnu::no_dangling]], which this patch implements. I didn't call it no_dangling_reference in the hope that it can, some day, be also used for some -Wdangling-pointer purposes. Bootstrapped/regtested on x86_64-pc-linux-gnu, ok for trunk? -- >8 -- Since -Wdangling-reference has false positives that can't be prevented, we should offer an easy way to suppress the warning. Currently, that is only possible by using a #pragma, either around the enclosing class or around the call site. But #pragma GCC diagnostic tend to be onerous. A better solution would be to have an attribute. To that end, this patch adds a new attribute, [[gnu::no_dangling]]. This attribute takes an optional bool argument to support cases like: template struct [[gnu::no_dangling(std::is_reference_v)]] S { // ... }; PR c++/110358 PR c++/109642 gcc/cp/ChangeLog: * call.cc (no_dangling_p): New. (reference_like_class_p): Use it. (do_warn_dangling_reference): Use it. Don't warn when the function or its enclosing class has attribute gnu::no_dangling. * tree.cc (cxx_gnu_attributes): Add gnu::no_dangling. (handle_no_dangling_attribute): New. gcc/ChangeLog: * doc/extend.texi: Document gnu::no_dangling. * doc/invoke.texi: Mention that gnu::no_dangling disables -Wdangling-reference. gcc/testsuite/ChangeLog: * g++.dg/ext/attr-no-dangling1.C: New test. * g++.dg/ext/attr-no-dangling2.C: New test. * g++.dg/ext/attr-no-dangling3.C: New test. * g++.dg/ext/attr-no-dangling4.C: New test. * g++.dg/ext/attr-no-dangling5.C: New test. * g++.dg/ext/attr-no-dangling6.C: New test. * g++.dg/ext/attr-no-dangling7.C: New test. * g++.dg/ext/attr-no-dangling8.C: New test. * g++.dg/ext/attr-no-dangling9.C: New test. --- gcc/cp/call.cc | 38 ++++++++++-- gcc/cp/tree.cc | 26 ++++++++ gcc/doc/extend.texi | 21 +++++++ gcc/doc/invoke.texi | 21 +++++++ gcc/testsuite/g++.dg/ext/attr-no-dangling1.C | 38 ++++++++++++ gcc/testsuite/g++.dg/ext/attr-no-dangling2.C | 29 +++++++++ gcc/testsuite/g++.dg/ext/attr-no-dangling3.C | 24 ++++++++ gcc/testsuite/g++.dg/ext/attr-no-dangling4.C | 14 +++++ gcc/testsuite/g++.dg/ext/attr-no-dangling5.C | 31 ++++++++++ gcc/testsuite/g++.dg/ext/attr-no-dangling6.C | 65 ++++++++++++++++++++ gcc/testsuite/g++.dg/ext/attr-no-dangling7.C | 31 ++++++++++ gcc/testsuite/g++.dg/ext/attr-no-dangling8.C | 30 +++++++++ gcc/testsuite/g++.dg/ext/attr-no-dangling9.C | 25 ++++++++ 13 files changed, 387 insertions(+), 6 deletions(-) create mode 100644 gcc/testsuite/g++.dg/ext/attr-no-dangling1.C create mode 100644 gcc/testsuite/g++.dg/ext/attr-no-dangling2.C create mode 100644 gcc/testsuite/g++.dg/ext/attr-no-dangling3.C create mode 100644 gcc/testsuite/g++.dg/ext/attr-no-dangling4.C create mode 100644 gcc/testsuite/g++.dg/ext/attr-no-dangling5.C create mode 100644 gcc/testsuite/g++.dg/ext/attr-no-dangling6.C create mode 100644 gcc/testsuite/g++.dg/ext/attr-no-dangling7.C create mode 100644 gcc/testsuite/g++.dg/ext/attr-no-dangling8.C create mode 100644 gcc/testsuite/g++.dg/ext/attr-no-dangling9.C base-commit: cda3836161834c5f21f264885891fe4d0ce90da1 diff --git a/gcc/cp/call.cc b/gcc/cp/call.cc index c40ef2e3028..9e4c8073600 100644 --- a/gcc/cp/call.cc +++ b/gcc/cp/call.cc @@ -14033,11 +14033,7 @@ std_pair_ref_ref_p (tree t) return true; } -/* Return true if a class CTYPE is either std::reference_wrapper or - std::ref_view, or a reference wrapper class. We consider a class - a reference wrapper class if it has a reference member. We no - longer check that it has a constructor taking the same reference type - since that approach still generated too many false positives. */ +/* Return true if a class T has a reference member. */ static bool class_has_reference_member_p (tree t) @@ -14061,12 +14057,41 @@ class_has_reference_member_p_r (tree binfo, void *) ? integer_one_node : NULL_TREE); } + +/* Return true if T (either a class or a function) has been marked as + not-dangling. */ + +static bool +no_dangling_p (tree t) +{ + t = lookup_attribute ("no_dangling", TYPE_ATTRIBUTES (t)); + if (!t) + return false; + + t = TREE_VALUE (t); + if (!t) + return true; + + t = build_converted_constant_bool_expr (TREE_VALUE (t), tf_warning_or_error); + t = cxx_constant_value (t); + return t == boolean_true_node; +} + +/* Return true if a class CTYPE is either std::reference_wrapper or + std::ref_view, or a reference wrapper class. We consider a class + a reference wrapper class if it has a reference member. We no + longer check that it has a constructor taking the same reference type + since that approach still generated too many false positives. */ + static bool reference_like_class_p (tree ctype) { if (!CLASS_TYPE_P (ctype)) return false; + if (no_dangling_p (ctype)) + return true; + /* Also accept a std::pair. */ if (std_pair_ref_ref_p (ctype)) return true; @@ -14173,7 +14198,8 @@ do_warn_dangling_reference (tree expr, bool arg_p) but probably not to one of its arguments. */ || (DECL_OBJECT_MEMBER_FUNCTION_P (fndecl) && DECL_OVERLOADED_OPERATOR_P (fndecl) - && DECL_OVERLOADED_OPERATOR_IS (fndecl, INDIRECT_REF))) + && DECL_OVERLOADED_OPERATOR_IS (fndecl, INDIRECT_REF)) + || no_dangling_p (TREE_TYPE (fndecl))) return NULL_TREE; tree rettype = TREE_TYPE (TREE_TYPE (fndecl)); diff --git a/gcc/cp/tree.cc b/gcc/cp/tree.cc index ad312710f68..e75be9a4e66 100644 --- a/gcc/cp/tree.cc +++ b/gcc/cp/tree.cc @@ -47,6 +47,7 @@ static tree verify_stmt_tree_r (tree *, int *, void *); static tree handle_init_priority_attribute (tree *, tree, tree, int, bool *); static tree handle_abi_tag_attribute (tree *, tree, tree, int, bool *); static tree handle_contract_attribute (tree *, tree, tree, int, bool *); +static tree handle_no_dangling_attribute (tree *, tree, tree, int, bool *); /* If REF is an lvalue, returns the kind of lvalue that REF is. Otherwise, returns clk_none. */ @@ -5102,6 +5103,8 @@ static const attribute_spec cxx_gnu_attributes[] = handle_init_priority_attribute, NULL }, { "abi_tag", 1, -1, false, false, false, true, handle_abi_tag_attribute, NULL }, + { "no_dangling", 0, 1, false, true, false, false, + handle_no_dangling_attribute, NULL }, }; const scoped_attribute_specs cxx_gnu_attribute_table = @@ -5391,6 +5394,29 @@ handle_contract_attribute (tree *ARG_UNUSED (node), tree ARG_UNUSED (name), return NULL_TREE; } +/* Handle a "no_dangling" attribute; arguments as in + struct attribute_spec.handler. */ + +tree +handle_no_dangling_attribute (tree *node, tree name, tree args, int, + bool *no_add_attrs) +{ + if (args && TREE_CODE (TREE_VALUE (args)) == STRING_CST) + { + error ("%qE attribute argument must be an expression that evaluates " + "to true or false", name); + *no_add_attrs = true; + } + else if (!FUNC_OR_METHOD_TYPE_P (*node) + && !RECORD_OR_UNION_TYPE_P (*node)) + { + warning (OPT_Wattributes, "%qE attribute ignored", name); + *no_add_attrs = true; + } + + return NULL_TREE; +} + /* Return a new PTRMEM_CST of the indicated TYPE. The MEMBER is the thing pointed to by the constant. */ diff --git a/gcc/doc/extend.texi b/gcc/doc/extend.texi index efd78014d1a..571655bf39a 100644 --- a/gcc/doc/extend.texi +++ b/gcc/doc/extend.texi @@ -29317,6 +29317,27 @@ Some_Class B __attribute__ ((init_priority (543))); Note that the particular values of @var{priority} do not matter; only their relative ordering. +@cindex @code{no_dangling} type attribute +@item no_dangling + +This attribute can be applied on a class type, function, or member +function. Entities marked with this attribute will have the +@option{-Wdangling-reference} diagnostic suppressed. + +@smallexample +class [[gnu::no_dangling]] S @{ @dots{} @}; +@end smallexample + +This attribute takes an optional argument, which must be an expression that +evaluates to true or false: + +@smallexample +template +struct [[gnu::no_dangling(std::is_reference_v)]] S @{ + @dots{} +@}; +@end smallexample + @cindex @code{warn_unused} type attribute @item warn_unused diff --git a/gcc/doc/invoke.texi b/gcc/doc/invoke.texi index 7862c751801..9022a413dd4 100644 --- a/gcc/doc/invoke.texi +++ b/gcc/doc/invoke.texi @@ -3908,6 +3908,9 @@ const T& foo (const T&) @{ @dots{} @} #pragma GCC diagnostic pop @end smallexample +The @code{#pragma} can also surround the class; in that case, the warning +will be disabled for all the member functions. + @option{-Wdangling-reference} also warns about code like @smallexample @@ -3932,6 +3935,24 @@ struct Span @{ as @code{std::span}-like; that is, the class is a non-union class that has a pointer data member and a trivial destructor. +The warning can be disabled by using the @code{gnu::no_dangling} attribute, +which can be applied on the enclosing class type (in which case it disables +the warning for all its member functions), member function, or a regular +function. For example: + +@smallexample +class [[gnu::no_dangling]] A @{ + int *p; + int &foo() @{ return *p; @} +@}; + +[[gnu::no_dangling]] const int & +foo (const int &i) +@{ + @dots{} +@} +@end smallexample + This warning is enabled by @option{-Wall}. @opindex Wdelete-non-virtual-dtor diff --git a/gcc/testsuite/g++.dg/ext/attr-no-dangling1.C b/gcc/testsuite/g++.dg/ext/attr-no-dangling1.C new file mode 100644 index 00000000000..02eabbc5003 --- /dev/null +++ b/gcc/testsuite/g++.dg/ext/attr-no-dangling1.C @@ -0,0 +1,38 @@ +// { dg-do compile { target c++11 } } +// { dg-options "-Wdangling-reference" } + +int g = 42; + +struct [[gnu::no_dangling]] A { + int *i; + int &foo() { return *i; } +}; + +struct A2 { + int *i; + [[gnu::no_dangling]] int &foo() { return *i; } + [[gnu::no_dangling]] static int &bar (const int &) { return *&g; } +}; + +union [[gnu::no_dangling]] U { }; + +A a() { return A{&g}; } +A2 a2() { return A2{&g}; } + +class X { }; +const X x1; +const X x2; + +[[gnu::no_dangling]] const X& get(const int& i) +{ + return i == 0 ? x1 : x2; +} + +void +test () +{ + [[maybe_unused]] const X& x = get (10); // { dg-bogus "dangling" } + [[maybe_unused]] const int &i = a().foo(); // { dg-bogus "dangling" } + [[maybe_unused]] const int &j = a2().foo(); // { dg-bogus "dangling" } + [[maybe_unused]] const int &k = a2().bar(10); // { dg-bogus "dangling" } +} diff --git a/gcc/testsuite/g++.dg/ext/attr-no-dangling2.C b/gcc/testsuite/g++.dg/ext/attr-no-dangling2.C new file mode 100644 index 00000000000..4cdc97ea7c4 --- /dev/null +++ b/gcc/testsuite/g++.dg/ext/attr-no-dangling2.C @@ -0,0 +1,29 @@ +// { dg-do compile { target c++11 } } +// Negative tests. + +struct [[no_dangling]] A { // { dg-warning "ignored" } + [[no_dangling]] int &foo (int &); // { dg-warning "ignored" } +}; + +[[no_dangling]] int &bar (int &); // { dg-warning "ignored" } + +[[gnu::no_dangling]] int i; // { dg-warning "ignored" } +[[gnu::no_dangling]] double d; // { dg-warning "ignored" } +[[gnu::no_dangling]] typedef int T; // { dg-warning "ignored" } + +[[gnu::no_dangling()]] int &fn1 (int &); // { dg-error "parentheses" } +[[gnu::no_dangling("a")]] int &fn2 (int &); // { dg-error "must be an expression" } +[[gnu::no_dangling(true, true)]] int &fn3 (int &); // { dg-error "wrong number of arguments" } + +enum [[gnu::no_dangling]] E { // { dg-warning "ignored" } + X [[gnu::no_dangling]] // { dg-warning "ignored" } +}; + +[[gnu::no_dangling]]; // { dg-warning "ignored" } + +void +g () +{ + goto L; +[[gnu::no_dangling]] L:; // { dg-warning "ignored" } +} diff --git a/gcc/testsuite/g++.dg/ext/attr-no-dangling3.C b/gcc/testsuite/g++.dg/ext/attr-no-dangling3.C new file mode 100644 index 00000000000..764b104fd3c --- /dev/null +++ b/gcc/testsuite/g++.dg/ext/attr-no-dangling3.C @@ -0,0 +1,24 @@ +// { dg-do compile { target c++11 } } +// { dg-options "-Wdangling-reference" } + +template +struct [[gnu::no_dangling]] Span { + T* data_; + int len_; + // So that our heuristic doesn't suppress the warning anyway. + ~Span(); + + [[nodiscard]] constexpr auto operator[](int n) const noexcept -> T& { return data_[n]; } + [[nodiscard]] constexpr auto front() const noexcept -> T& { return data_[0]; } + [[nodiscard]] constexpr auto back() const noexcept -> T& { return data_[len_ - 1]; } +}; + +auto get() -> Span; + +auto f() -> int { + int const& a = get().front(); // { dg-bogus "dangling" } + int const& b = get().back(); // { dg-bogus "dangling" } + int const& c = get()[0]; // { dg-bogus "dangling" } + + return a + b + c; +} diff --git a/gcc/testsuite/g++.dg/ext/attr-no-dangling4.C b/gcc/testsuite/g++.dg/ext/attr-no-dangling4.C new file mode 100644 index 00000000000..e910723d985 --- /dev/null +++ b/gcc/testsuite/g++.dg/ext/attr-no-dangling4.C @@ -0,0 +1,14 @@ +// { dg-do compile { target c++11 } } + +#if !__has_attribute(no_dangling) +#error unsupported +#endif + +#ifdef __has_cpp_attribute +# if !__has_cpp_attribute(no_dangling) +# error no_dangling +# endif +#endif + +struct [[gnu::no_dangling]] S { }; +static_assert (__builtin_has_attribute (S, no_dangling), ""); diff --git a/gcc/testsuite/g++.dg/ext/attr-no-dangling5.C b/gcc/testsuite/g++.dg/ext/attr-no-dangling5.C new file mode 100644 index 00000000000..ec5075482c4 --- /dev/null +++ b/gcc/testsuite/g++.dg/ext/attr-no-dangling5.C @@ -0,0 +1,31 @@ +// PR c++/110358 +// { dg-do compile { target c++20 } } +// { dg-options "-Wdangling-reference" } + +template +struct Span { + T* data_; + int len_; + ~Span(); + + [[nodiscard]] constexpr auto operator[](int n) const noexcept -> T& { return data_[n]; } +}; + +template <> +struct [[gnu::no_dangling]] Span { + int* data_; + int len_; + ~Span(); + + [[nodiscard]] constexpr auto operator[](int n) const noexcept -> int& { return data_[n]; } +}; + +auto getch() -> Span; +auto geti() -> Span; + +void +f () +{ + [[maybe_unused]] const auto &a = getch()[0]; // { dg-warning "dangling reference" } + [[maybe_unused]] const auto &b = geti()[0]; // { dg-bogus "dangling reference" } +} diff --git a/gcc/testsuite/g++.dg/ext/attr-no-dangling6.C b/gcc/testsuite/g++.dg/ext/attr-no-dangling6.C new file mode 100644 index 00000000000..235a5fd86c5 --- /dev/null +++ b/gcc/testsuite/g++.dg/ext/attr-no-dangling6.C @@ -0,0 +1,65 @@ +// PR c++/110358 +// { dg-do compile { target c++20 } } +// { dg-options "-Wdangling-reference" } + +class X { }; +const X x1; +const X x2; + +constexpr bool val () { return true; } +struct ST { static constexpr bool value = true; }; +struct SF { static constexpr bool value = false; }; + +template +[[gnu::no_dangling(T::value)]] +const X& get (const int& i) +{ + return i == 0 ? x1 : x2; +} + +template +[[gnu::no_dangling(B)]] +const X& foo (const int& i) +{ + return i == 0 ? x1 : x2; +} + +[[gnu::no_dangling(val ())]] +const X& bar (const int& i) +{ + return i == 0 ? x1 : x2; +} + +[[gnu::no_dangling(!val ())]] +const X& baz (const int& i) +{ + return i == 0 ? x1 : x2; +} + +template +struct [[gnu::no_dangling(T::value)]] +Span { + T* data_; + int len_; + ~Span(); + + [[nodiscard]] constexpr auto operator[](int n) const noexcept -> T& { return data_[n]; } +}; + +auto geti() -> Span; +auto gety() -> Span; + +void +test () +{ + [[maybe_unused]] const X& x1 = get (10); // { dg-bogus "dangling" } + [[maybe_unused]] const X& x2 = get (10); // { dg-warning "dangling" } + [[maybe_unused]] const X& x3 = foo (10); // { dg-bogus "dangling" } + [[maybe_unused]] const X& x4 = foo (10); // { dg-warning "dangling" } + [[maybe_unused]] const X& x7 = foo<> (10); // { dg-bogus "dangling" } + [[maybe_unused]] const X& x5 = bar (10); // { dg-bogus "dangling" } + [[maybe_unused]] const X& x6 = baz (10); // { dg-warning "dangling" } + + [[maybe_unused]] const auto &b1 = geti()[0]; // { dg-bogus "dangling" } + [[maybe_unused]] const auto &b2 = gety()[0]; // { dg-warning "dangling" } +} diff --git a/gcc/testsuite/g++.dg/ext/attr-no-dangling7.C b/gcc/testsuite/g++.dg/ext/attr-no-dangling7.C new file mode 100644 index 00000000000..3c392ed409f --- /dev/null +++ b/gcc/testsuite/g++.dg/ext/attr-no-dangling7.C @@ -0,0 +1,31 @@ +// PR c++/110358 +// { dg-do compile { target c++20 } } +// { dg-options "-Wdangling-reference" } + +class X { }; +const X x1; +const X x2; + +template +[[gnu::no_dangling(N)]] const X& get(const int& i); // { dg-error "parameter packs not expanded" } + +template +[[gnu::no_dangling(T::x)]] // { dg-error "member" } +const X& foo(const int& i); + +bool val () { return true; } + +[[gnu::no_dangling(val ())]] // { dg-error "call" } +const X& bar (const int& i); + +[[gnu::no_dangling(20)]] const X& fn1 (const int &); + +void +test () +{ + [[maybe_unused]] const X& x1 = bar (10); // { dg-warning "dangling" } + [[maybe_unused]] const X& x2 = foo (10); // { dg-error "no matching" } + [[maybe_unused]] const X& x3 // { dg-warning "dangling" } + = fn1 (10); // { dg-error "narrowing" } +} + diff --git a/gcc/testsuite/g++.dg/ext/attr-no-dangling8.C b/gcc/testsuite/g++.dg/ext/attr-no-dangling8.C new file mode 100644 index 00000000000..8208d751a4b --- /dev/null +++ b/gcc/testsuite/g++.dg/ext/attr-no-dangling8.C @@ -0,0 +1,30 @@ +// PR c++/110358 +// { dg-do compile { target c++20 } } +// { dg-options "-Wdangling-reference" } + +template constexpr bool is_reference_v = false; +template constexpr bool is_reference_v = true; +template constexpr bool is_reference_v = true; + +template +struct [[gnu::no_dangling(is_reference_v)]] S { + int &foo (const int &); +}; + +template +struct X { + template + struct [[gnu::no_dangling(is_reference_v && is_reference_v)]] Y { + int &foo (const int &); + }; +}; + +void +g () +{ + [[maybe_unused]] const int &x0 = S().foo (42); // { dg-bogus "dangling" } + [[maybe_unused]] const int &x1 = S().foo (42); // { dg-warning "dangling" } + [[maybe_unused]] const auto &x2 = X::Y<>().foo (42); // { dg-warning "dangling" } + [[maybe_unused]] const auto &x3 = X::Y<>().foo (42); // { dg-bogus "dangling" } +} + diff --git a/gcc/testsuite/g++.dg/ext/attr-no-dangling9.C b/gcc/testsuite/g++.dg/ext/attr-no-dangling9.C new file mode 100644 index 00000000000..65b4f7145a9 --- /dev/null +++ b/gcc/testsuite/g++.dg/ext/attr-no-dangling9.C @@ -0,0 +1,25 @@ +// PR c++/110358 +// { dg-do compile { target c++20 } } +// { dg-options "-Wdangling-reference" } + +template +struct bool_constant { + static constexpr bool value = B; + constexpr operator bool() const { return value; } +}; + +using true_type = bool_constant; +using false_type = bool_constant; + +struct S { + template + [[gnu::no_dangling(B)]] int &foo (const int &); +}; + +void +g () +{ + [[maybe_unused]] const int &x0 = S().foo (42); // { dg-warning "dangling" } + [[maybe_unused]] const int &x1 = S().foo (42); // { dg-bogus "dangling" } +} +