From patchwork Thu Jul 18 04:29:59 2024 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Andi Kleen X-Patchwork-Id: 1961887 Return-Path: X-Original-To: incoming@patchwork.ozlabs.org Delivered-To: patchwork-incoming@legolas.ozlabs.org Authentication-Results: legolas.ozlabs.org; dkim=pass (2048-bit key; unprotected) header.d=intel.com header.i=@intel.com header.a=rsa-sha256 header.s=Intel header.b=SZhovkjg; dkim-atps=neutral Authentication-Results: legolas.ozlabs.org; spf=pass (sender SPF authorized) smtp.mailfrom=gcc.gnu.org (client-ip=2620:52:3:1:0:246e:9693:128c; helo=server2.sourceware.org; envelope-from=gcc-patches-bounces~incoming=patchwork.ozlabs.org@gcc.gnu.org; receiver=patchwork.ozlabs.org) Received: from server2.sourceware.org (server2.sourceware.org [IPv6:2620:52:3:1:0:246e:9693:128c]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature ECDSA (secp384r1) server-digest SHA384) (No client certificate requested) by legolas.ozlabs.org (Postfix) with ESMTPS id 4WPg6Y4lFSz1yY1 for ; Thu, 18 Jul 2024 14:38:29 +1000 (AEST) Received: from server2.sourceware.org (localhost [IPv6:::1]) by sourceware.org (Postfix) with ESMTP id 9642D386074C for ; Thu, 18 Jul 2024 04:38:27 +0000 (GMT) X-Original-To: gcc-patches@gcc.gnu.org Delivered-To: gcc-patches@gcc.gnu.org Received: from mgamail.intel.com (mgamail.intel.com [192.198.163.19]) by sourceware.org (Postfix) with ESMTPS id DD8D6385C6C9 for ; Thu, 18 Jul 2024 04:37:57 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.4.2 sourceware.org DD8D6385C6C9 Authentication-Results: sourceware.org; dmarc=none (p=none dis=none) header.from=linux.intel.com Authentication-Results: sourceware.org; spf=none smtp.mailfrom=linux.intel.com ARC-Filter: OpenARC Filter v1.0.0 sourceware.org DD8D6385C6C9 Authentication-Results: server2.sourceware.org; arc=none smtp.remote-ip=192.198.163.19 ARC-Seal: i=1; a=rsa-sha256; d=sourceware.org; s=key; t=1721277480; cv=none; b=dyl/J83Olc7ZMimF5NouaXmHWAkEU5d0a/pj77dTdbWggHYbxY2Fw8DWdUC8kcdUyynQ3dT04c/HD6NSjJIEozBN2XjNhD4oqroKrDmlKhHDywoTJ4s1tzdvJfcUV1gQVSu1NvA+t3hYRZR1vuY2RQVAmZE7M3A0SrB3G8RoSp4= ARC-Message-Signature: i=1; a=rsa-sha256; d=sourceware.org; s=key; t=1721277480; c=relaxed/simple; bh=V54JdRIwyIHXcHwl1wwZ/9d7GUYZrB8R5/ZnpXBiGI4=; h=DKIM-Signature:From:To:Subject:Date:Message-ID:MIME-Version; b=bp7dsylsFhYFOrzKMSa1roKsMCq8FAsMYAUwILx1exO3JpsvSDMV1zaVHW2vC3K5lbbWiIS1zQoOk4JN6tuN2yD77wWPX3FJbuFtrGnB3c8SxM0Kzy+WDhQ5ua9Z9Bazs17SHd0OmIunBfC8rO1u/YG9OP6a4DrfoMNjVvZnGHI= ARC-Authentication-Results: i=1; server2.sourceware.org DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=intel.com; i=@intel.com; q=dns/txt; s=Intel; t=1721277478; x=1752813478; h=from:to:cc:subject:date:message-id:in-reply-to: references:mime-version:content-transfer-encoding; bh=V54JdRIwyIHXcHwl1wwZ/9d7GUYZrB8R5/ZnpXBiGI4=; b=SZhovkjgTRBzeuup+irD8bbV7i50NDoJouaauDlSJK5d5/NWOiaZzBeG TcmmmWgvKvDsSAoWmpJNYlsZ4mP8j/TNnjvAU54/4TKioAwoRW8ovIoku wuYvr61/cMY2a4FqBKraaoniLOAGwAG5mlIHahC1pzsgjSl0oJ/SlI2ix SmjAUXftjdBc9UEpwc+o7zUUUENsCzfBctt6x9tg4PNDqGM8dClrHYYSC mGItNy+URxw5yG2l46FZqg2OwxvnqrjYMiw3vfTAHe43MddfKiO7T/oy8 mQ0JhLs5jLGeLuGVWPGgUGm+0sbHowbitfZNBmURK2f+BNyBD2PGy8nGN w==; X-CSE-ConnectionGUID: FgU+7f5qR0Svs9IIzZqAow== X-CSE-MsgGUID: +cHC/siWSHa6QsE0MFEP7w== X-IronPort-AV: E=McAfee;i="6700,10204,11136"; a="18515139" X-IronPort-AV: E=Sophos;i="6.09,216,1716274800"; d="scan'208";a="18515139" Received: from fmviesa003.fm.intel.com ([10.60.135.143]) by fmvoesa113.fm.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 17 Jul 2024 21:37:56 -0700 X-CSE-ConnectionGUID: rLM3aVIIQY61h8coQpUDvQ== X-CSE-MsgGUID: ODaVS3RQRWe0+sFF5CRcrA== X-ExtLoop1: 1 X-IronPort-AV: E=Sophos;i="6.09,216,1716274800"; d="scan'208";a="54810593" Received: from tassilo.jf.intel.com ([10.54.38.190]) by fmviesa003-auth.fm.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 17 Jul 2024 21:37:57 -0700 From: Andi Kleen To: gcc-patches@gcc.gnu.org Cc: polacek@redhat.com, josmyers@redhat.com, jason@redhat.com, Andi Kleen Subject: [PATCH v10 1/3] C++: Support clang compatible [[musttail]] (PR83324) Date: Wed, 17 Jul 2024 21:29:59 -0700 Message-ID: <20240718043750.2480283-2-ak@linux.intel.com> X-Mailer: git-send-email 2.45.2 In-Reply-To: <20240718043750.2480283-1-ak@linux.intel.com> References: <20240718043750.2480283-1-ak@linux.intel.com> MIME-Version: 1.0 X-Spam-Status: No, score=-10.9 required=5.0 tests=BAYES_00, DKIMWL_WL_HIGH, DKIM_SIGNED, DKIM_VALID, DKIM_VALID_EF, GIT_PATCH_0, 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.30 Precedence: list List-Id: Gcc-patches mailing list List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: gcc-patches-bounces~incoming=patchwork.ozlabs.org@gcc.gnu.org This patch implements a clang compatible [[musttail]] attribute for returns. musttail is useful as an alternative to computed goto for interpreters. With computed goto the interpreter function usually ends up very big which causes problems with register allocation and other per function optimizations not scaling. With musttail the interpreter can be instead written as a sequence of smaller functions that call each other. To avoid unbounded stack growth this requires forcing a sibling call, which this attribute does. It guarantees an error if the call cannot be tail called which allows the programmer to fix it instead of risking a stack overflow. Unlike computed goto it is also type-safe. It turns out that David Malcolm had already implemented middle/backend support for a musttail attribute back in 2016, but it wasn't exposed to any frontend other than a special plugin. This patch adds a [[gnu::musttail]] attribute for C++ that can be added to return statements. The return statement must be a direct call (it does not follow dependencies), which is similar to what clang implements. It then uses the existing must tail infrastructure. For compatibility it also detects clang::musttail Passes bootstrap and full test gcc/c-family/ChangeLog: * c-attribs.cc (set_musttail_on_return): New function. * c-common.h (set_musttail_on_return): Declare new function. gcc/cp/ChangeLog: PR c/83324 * cp-tree.h (AGGR_INIT_EXPR_MUST_TAIL): Add. * parser.cc (cp_parser_statement): Handle musttail. (cp_parser_jump_statement): Dito. * pt.cc (tsubst_expr): Copy CALL_EXPR_MUST_TAIL_CALL. * semantics.cc (simplify_aggr_init_expr): Handle musttail. --- gcc/c-family/c-attribs.cc | 20 ++++++++++++++++++++ gcc/c-family/c-common.h | 1 + gcc/cp/cp-tree.h | 4 ++++ gcc/cp/parser.cc | 32 +++++++++++++++++++++++++++++--- gcc/cp/pt.cc | 9 ++++++++- gcc/cp/semantics.cc | 1 + 6 files changed, 63 insertions(+), 4 deletions(-) diff --git a/gcc/c-family/c-attribs.cc b/gcc/c-family/c-attribs.cc index 5adc7b775eaf..685f212683f4 100644 --- a/gcc/c-family/c-attribs.cc +++ b/gcc/c-family/c-attribs.cc @@ -672,6 +672,26 @@ attribute_takes_identifier_p (const_tree attr_id) return targetm.attribute_takes_identifier_p (attr_id); } +/* Set a musttail attribute MUSTTAIL_P on return expression RETVAL + at LOC. */ + +void +set_musttail_on_return (tree retval, location_t loc, bool musttail_p) +{ + if (retval && musttail_p) + { + tree t = retval; + if (TREE_CODE (t) == TARGET_EXPR) + t = TARGET_EXPR_INITIAL (t); + if (TREE_CODE (t) != CALL_EXPR) + error_at (loc, "cannot tail-call: return value must be a call"); + else + CALL_EXPR_MUST_TAIL_CALL (t) = 1; + } + else if (musttail_p && !retval) + error_at (loc, "cannot tail-call: return value must be a call"); +} + /* Verify that argument value POS at position ARGNO to attribute NAME applied to function FN (which is either a function declaration or function type) refers to a function parameter at position POS and the expected type diff --git a/gcc/c-family/c-common.h b/gcc/c-family/c-common.h index adee822a3ae0..2510ee4dbc9d 100644 --- a/gcc/c-family/c-common.h +++ b/gcc/c-family/c-common.h @@ -1648,6 +1648,7 @@ extern tree handle_noreturn_attribute (tree *, tree, tree, int, bool *); extern tree handle_musttail_attribute (tree *, tree, tree, int, bool *); extern bool has_attribute (location_t, tree, tree, tree (*)(tree)); extern tree build_attr_access_from_parms (tree, bool); +extern void set_musttail_on_return (tree, location_t, bool); /* In c-format.cc. */ extern bool valid_format_string_type_p (tree); diff --git a/gcc/cp/cp-tree.h b/gcc/cp/cp-tree.h index c6f102564ce0..67ba3274eb1b 100644 --- a/gcc/cp/cp-tree.h +++ b/gcc/cp/cp-tree.h @@ -4236,6 +4236,10 @@ templated_operator_saved_lookups (tree t) #define AGGR_INIT_FROM_THUNK_P(NODE) \ (AGGR_INIT_EXPR_CHECK (NODE)->base.protected_flag) +/* Nonzero means that the call was marked musttail. */ +#define AGGR_INIT_EXPR_MUST_TAIL(NODE) \ + (AGGR_INIT_EXPR_CHECK (NODE)->base.static_flag) + /* AGGR_INIT_EXPR accessors. These are equivalent to the CALL_EXPR accessors, except for AGGR_INIT_EXPR_SLOT (which takes the place of CALL_EXPR_STATIC_CHAIN). */ diff --git a/gcc/cp/parser.cc b/gcc/cp/parser.cc index efd5d6f29a71..71bffd4a9311 100644 --- a/gcc/cp/parser.cc +++ b/gcc/cp/parser.cc @@ -2467,7 +2467,7 @@ static tree cp_parser_perform_range_for_lookup static tree cp_parser_range_for_member_function (tree, tree); static tree cp_parser_jump_statement - (cp_parser *); + (cp_parser *, tree &); static void cp_parser_declaration_statement (cp_parser *); @@ -12757,7 +12757,7 @@ cp_parser_statement (cp_parser* parser, tree in_statement_expr, case RID_CO_RETURN: case RID_GOTO: std_attrs = process_stmt_hotness_attribute (std_attrs, attrs_loc); - statement = cp_parser_jump_statement (parser); + statement = cp_parser_jump_statement (parser, std_attrs); break; /* Objective-C++ exception-handling constructs. */ @@ -14845,10 +14845,11 @@ cp_parser_init_statement (cp_parser *parser, tree *decl) jump-statement: goto * expression ; + STD_ATTRS are the statement attributes. They can be modified. Returns the new BREAK_STMT, CONTINUE_STMT, RETURN_EXPR, or GOTO_EXPR. */ static tree -cp_parser_jump_statement (cp_parser* parser) +cp_parser_jump_statement (cp_parser* parser, tree &std_attrs) { tree statement = error_mark_node; cp_token *token; @@ -14925,6 +14926,31 @@ cp_parser_jump_statement (cp_parser* parser) /* If the next token is a `;', then there is no expression. */ expr = NULL_TREE; + + if (keyword == RID_RETURN && expr) + { + bool musttail_p = false; + if (lookup_attribute ("gnu", "musttail", std_attrs)) + { + musttail_p = true; + std_attrs = remove_attribute ("gnu", "musttail", std_attrs); + } + /* Support this for compatibility. */ + if (lookup_attribute ("clang", "musttail", std_attrs)) + { + musttail_p = true; + std_attrs = remove_attribute ("clang", "musttail", std_attrs); + } + + tree ret_expr = expr; + if (TREE_CODE (ret_expr) == TARGET_EXPR) + ret_expr = TARGET_EXPR_INITIAL (ret_expr); + if (TREE_CODE (ret_expr) == AGGR_INIT_EXPR) + AGGR_INIT_EXPR_MUST_TAIL (ret_expr) = musttail_p; + else + set_musttail_on_return (expr, token->location, musttail_p); + } + /* Build the return-statement, check co-return first, since type deduction is not valid there. */ if (keyword == RID_CO_RETURN) diff --git a/gcc/cp/pt.cc b/gcc/cp/pt.cc index 057797f213f5..148f461d4fb8 100644 --- a/gcc/cp/pt.cc +++ b/gcc/cp/pt.cc @@ -21089,12 +21089,19 @@ tsubst_expr (tree t, tree args, tsubst_flags_t complain, tree in_decl) bool op = CALL_EXPR_OPERATOR_SYNTAX (t); bool ord = CALL_EXPR_ORDERED_ARGS (t); bool rev = CALL_EXPR_REVERSE_ARGS (t); - if (op || ord || rev) + bool mtc = false; + if (TREE_CODE (t) == CALL_EXPR) + mtc = CALL_EXPR_MUST_TAIL_CALL (t); + if (op || ord || rev || mtc) if (tree call = extract_call_expr (ret)) { CALL_EXPR_OPERATOR_SYNTAX (call) = op; CALL_EXPR_ORDERED_ARGS (call) = ord; CALL_EXPR_REVERSE_ARGS (call) = rev; + if (TREE_CODE (call) == CALL_EXPR) + CALL_EXPR_MUST_TAIL_CALL (call) = mtc; + else if (TREE_CODE (call) == AGGR_INIT_EXPR) + AGGR_INIT_EXPR_MUST_TAIL (call) = mtc; } if (warning_suppressed_p (t, OPT_Wpessimizing_move)) /* This also suppresses -Wredundant-move. */ diff --git a/gcc/cp/semantics.cc b/gcc/cp/semantics.cc index c21572e5d7f7..0f122b839c5f 100644 --- a/gcc/cp/semantics.cc +++ b/gcc/cp/semantics.cc @@ -4979,6 +4979,7 @@ simplify_aggr_init_expr (tree *tp) = CALL_EXPR_OPERATOR_SYNTAX (aggr_init_expr); CALL_EXPR_ORDERED_ARGS (call_expr) = CALL_EXPR_ORDERED_ARGS (aggr_init_expr); CALL_EXPR_REVERSE_ARGS (call_expr) = CALL_EXPR_REVERSE_ARGS (aggr_init_expr); + CALL_EXPR_MUST_TAIL_CALL (call_expr) = AGGR_INIT_EXPR_MUST_TAIL (aggr_init_expr); if (style == ctor) {