From patchwork Tue May 21 14:28:36 2024 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Andi Kleen X-Patchwork-Id: 1937458 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=Oo4QXWsU; dkim-atps=neutral Authentication-Results: legolas.ozlabs.org; spf=pass (sender SPF authorized) smtp.mailfrom=gcc.gnu.org (client-ip=8.43.85.97; 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 [8.43.85.97]) (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 4VkH3f3Sp6z20KF for ; Wed, 22 May 2024 00:33:18 +1000 (AEST) Received: from server2.sourceware.org (localhost [IPv6:::1]) by sourceware.org (Postfix) with ESMTP id C77E9384AB79 for ; Tue, 21 May 2024 14:33:16 +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 [198.175.65.14]) by sourceware.org (Postfix) with ESMTPS id F1E38384AB43 for ; Tue, 21 May 2024 14:32:24 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.4.2 sourceware.org F1E38384AB43 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 F1E38384AB43 Authentication-Results: server2.sourceware.org; arc=none smtp.remote-ip=198.175.65.14 ARC-Seal: i=1; a=rsa-sha256; d=sourceware.org; s=key; t=1716301949; cv=none; b=URzWi7smszZXLQ6gLP3BXQE+j9wU/l8PwfA5d1Mo5WToKNdsP4zWACwapK4tsW/G2bhClowCl9GL+fIqsAHuwmzRlokT/DGibks7AzUuw34ftiK0ytiTxueLgAqdDejM+HguIqALtrCuXNpPZ37GcK1h0UuTnWjod/PHutK+6G0= ARC-Message-Signature: i=1; a=rsa-sha256; d=sourceware.org; s=key; t=1716301949; c=relaxed/simple; bh=MstMhyMhwtif5HoBZsEzHyW5sv2HlsH98uqgFNCqpOk=; h=DKIM-Signature:From:To:Subject:Date:Message-ID:MIME-Version; b=RJOgSV1W2/lK85MJtgdESu8IFJvcuLnkWPpCa1dAzGLdwOKW02cwQj1ryzJ/fkCfqCUHlZKPJIZZeV9PJZzDEbbU6c2HcNnBltNqLmoZX+JkKJVG5+4R8VkXzrN25VWA6eU14Exd2+02QOqcenpmonZn8NiYLXiekMxQ4+h24KE= 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=1716301945; x=1747837945; h=from:to:cc:subject:date:message-id:in-reply-to: references:mime-version:content-transfer-encoding; bh=MstMhyMhwtif5HoBZsEzHyW5sv2HlsH98uqgFNCqpOk=; b=Oo4QXWsUN2Ltz9LlNxXQGMlf8UML3ygx5yWHAzOj4z6d0hxTSdsHwSxX QWZkEDrFJFoe94M7g55QZTFQpo5H/VsbJ7goLFNHa6queLr3xbllXM4KN Bg7b8M07SApEOWPSB9HA/VcyzNE5wa+WE1Y/+zzxDMnBGJYShz9BKt1ds /MUVk2BdhXburRNqz7KcdkK3tHQgJDBVzsCkkzHZHfzyB4NSU9sU42WXi /qbUh2nNjGcLVduh2ZNIXZIgfOQtWWsq0iAwu3rr2U2LdD8194VS9Gvuq AmkG3G+ByRsuqcILmEbdQama8hOBlCbKU7VECxAjBBiL6pNS7iSmOm/tC w==; X-CSE-ConnectionGUID: EZVTrXgPSeOHcSg9KvypBg== X-CSE-MsgGUID: w82hR2IjTWCQpA0CWTy4+w== X-IronPort-AV: E=McAfee;i="6600,9927,11078"; a="16328262" X-IronPort-AV: E=Sophos;i="6.08,178,1712646000"; d="scan'208";a="16328262" Received: from fmviesa001.fm.intel.com ([10.60.135.141]) by orvoesa106.jf.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 21 May 2024 07:32:19 -0700 X-CSE-ConnectionGUID: Imfu6S58QjqUhp1pqsQBow== X-CSE-MsgGUID: 9/28xlQWS/aOLf5Zr57VVg== X-ExtLoop1: 1 X-IronPort-AV: E=Sophos;i="6.08,178,1712646000"; d="scan'208";a="64166848" Received: from tassilo.jf.intel.com ([10.54.38.190]) by smtpauth.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 21 May 2024 07:32:19 -0700 From: Andi Kleen To: gcc-patches@gcc.gnu.org Cc: richard.guenther@gmail.com, nathan@acm.org, josmyers@redhat.com, richard.sandiford@arm.com, jason@redhat.com, Andi Kleen Subject: [PATCH v6 3/8] C++: Support clang compatible [[musttail]] (PR83324) Date: Tue, 21 May 2024 07:28:36 -0700 Message-ID: <20240521143203.2893096-4-ak@linux.intel.com> X-Mailer: git-send-email 2.44.0 In-Reply-To: <20240521143203.2893096-1-ak@linux.intel.com> References: <20240521143203.2893096-1-ak@linux.intel.com> MIME-Version: 1.0 X-Spam-Status: No, score=-11.0 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 One problem is that tree-tailcall usually fails when optimization is disabled, which implies the attribute only really works with optimization on. But that seems to be a reasonable limitation. Passes bootstrap and full test PR83324 gcc/cp/ChangeLog: * parser.cc (cp_parser_statement): Handle musttail. (cp_parser_jump_statement): Dito. (cp_parser_std_attribute): Dito. --- gcc/cp/parser.cc | 42 +++++++++++++++++++++++++++++++++++++----- 1 file changed, 37 insertions(+), 5 deletions(-) diff --git a/gcc/cp/parser.cc b/gcc/cp/parser.cc index 66ce161252c7..d25c1a1ac6a5 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 *); @@ -12734,13 +12734,17 @@ cp_parser_statement (cp_parser* parser, tree in_statement_expr, NULL_TREE, false); break; + case RID_RETURN: + std_attrs = process_stmt_hotness_attribute (std_attrs, attrs_loc); + statement = cp_parser_jump_statement (parser, std_attrs); + break; + case RID_BREAK: case RID_CONTINUE: - case RID_RETURN: 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. */ @@ -14797,10 +14801,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; @@ -14877,6 +14882,33 @@ 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); + } + if (musttail_p) + { + tree t = expr; + if (t && TREE_CODE (t) == TARGET_EXPR) + t = TARGET_EXPR_INITIAL (t); + if (t && TREE_CODE (t) != CALL_EXPR) + error_at (token->location, "cannot tail-call: return value must be a call"); + else + CALL_EXPR_MUST_TAIL_CALL (t) = 1; + } + } + /* Build the return-statement, check co-return first, since type deduction is not valid there. */ if (keyword == RID_CO_RETURN) @@ -30189,7 +30221,7 @@ cp_parser_std_attribute (cp_parser *parser, tree attr_ns) /* Maybe we don't expect to see any arguments for this attribute. */ const attribute_spec *as = lookup_attribute_spec (TREE_PURPOSE (attribute)); - if (as && as->max_length == 0) + if ((as && as->max_length == 0) || is_attribute_p ("musttail", attr_id)) { error_at (token->location, "%qE attribute does not take any arguments", attr_id);