From patchwork Wed Jan 31 02:17:15 2024 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Andi Kleen X-Patchwork-Id: 194436 Return-Path: Delivered-To: ouuuleilei@gmail.com Received: by 2002:a05:7301:2087:b0:106:209c:c626 with SMTP id gs7csp1626053dyb; Tue, 30 Jan 2024 18:19:39 -0800 (PST) X-Google-Smtp-Source: AGHT+IEKTfEwaBOJgR03olQMVgg3q/+fonOqqncK0XuyMylgsJ7hlkF9ut5gfYfUj8MYJKG6Qz0l X-Received: by 2002:a05:622a:1116:b0:42a:a861:3779 with SMTP id e22-20020a05622a111600b0042aa8613779mr498540qty.61.1706667579666; Tue, 30 Jan 2024 18:19:39 -0800 (PST) ARC-Seal: i=2; a=rsa-sha256; t=1706667579; cv=pass; d=google.com; s=arc-20160816; b=s6YDzhMgPcEeIDBwGUnwziK8LbcYMf4hwIA47oNULK+en/c7iszGPASp+6me+Xp8PM TtNwrLt/buE8ym9YBLaCKYX7ogJIy8gbwrupvJU/aTUmrTcSZZzSuB3Lp3fo4NwTPCzG 02/2bNDwKPAWlTIbB4vntq73o6TmBIRPskQVNdSzwxXhOEylcedonZH+YthUxPDH2lf9 wpSaklyTBrLUmtEYvSSJA1idDWyalexf5b4oWgRCjFvlPkVP5qYst0IwEYl37bTmX3Ct f3FbtWJ2/7Tmx8Ko1FJTN4DFrBdKDm4hR3vZAytdtRQUcCyc3Bmp3q+Cb9k77QQNTYwS O5JQ== 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-transfer-encoding :mime-version:references:in-reply-to:message-id:date:subject:cc:to :from:dkim-signature:arc-filter:dmarc-filter:delivered-to; bh=2glFZEvLjhbNEmF+v+LuJl8LP1zL0MH88tcqRu3KM0o=; fh=bdOTpCW975APsyKeWdNriw5lsN/Yo2TJAynqYuv1ijc=; b=RSeJxfJ2GNF9eAdjSybHb63gBUpGzHUTv5Qrr+hRoqcq2rRJht9oZcDWvwDYCOeOCl xl5mFTyrwGIa3en+o3Iorap7LaIXVAcHmFrH4FFHeGlmHWJK3cFJ/JSAXZCkEQ+0J+n3 uJuvaAhuCl5InGewiZ3b7MZ60rEno/QsurINa7tOKEacs30NEIkDD8tJ1p5BVQhKdtbP 5MMwUN9y7RnS24Y0NkOGOnnBYnNHFPTLxCZj7wN8LRKazMyhDYsxY5aSlQwy31V3iVVC 4nUgtjpBDJJ6pk3KTnGpgzFOf+zgp4z0l5yPFFI6EigYIgzORj4Zxfnu1at0zjCjkfSG RTrg==; dara=google.com ARC-Authentication-Results: i=2; mx.google.com; dkim=pass header.i=@intel.com header.s=Intel header.b=K7VkLfqY; 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=intel.com X-Forwarded-Encrypted: i=1; AJvYcCVrDD+F/zqCBnZ2qmVdVEmUNsvqpeG1hb1bWI9DRs7KMyvGfPmcRzsbVKjpUu9HQssK+d9eIlY0mfjeyJo16+FhOJ/jUA== Received: from server2.sourceware.org (server2.sourceware.org. [2620:52:3:1:0:246e:9693:128c]) by mx.google.com with ESMTPS id 20-20020ac85914000000b0042a7218fa38si11391447qty.381.2024.01.30.18.19.39 for (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Tue, 30 Jan 2024 18:19:39 -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=@intel.com header.s=Intel header.b=K7VkLfqY; 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=intel.com Received: from server2.sourceware.org (localhost [IPv6:::1]) by sourceware.org (Postfix) with ESMTP id 5D8AF38582BE for ; Wed, 31 Jan 2024 02:19:39 +0000 (GMT) X-Original-To: gcc-patches@gcc.gnu.org Delivered-To: gcc-patches@gcc.gnu.org Received: from eggs.gnu.org (eggs.gnu.org [IPv6:2001:470:142:3::10]) by sourceware.org (Postfix) with ESMTPS id A8944385840D for ; Wed, 31 Jan 2024 02:18:36 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.4.2 sourceware.org A8944385840D 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 A8944385840D Authentication-Results: server2.sourceware.org; arc=none smtp.remote-ip=2001:470:142:3::10 ARC-Seal: i=1; a=rsa-sha256; d=sourceware.org; s=key; t=1706667519; cv=none; b=kUMCcFAefKDxQ6xgUI6j4BAdfOq2ekMexv+o2R9KUu5jgtVvuZOyxQQro07zrkziIp+oMfiMbQ+XN1FjYA3hkvz5R95gmJNhlaSp7YYBZeEme56YtcEpnblAcT4M9712OHiOjYRFvkP2h7df0Xf7MIpzPduWMDllCbpP0FShT0Q= ARC-Message-Signature: i=1; a=rsa-sha256; d=sourceware.org; s=key; t=1706667519; c=relaxed/simple; bh=/tI4mAEmWiEwyCi4dXHq1Y2snm9zqK1o3c/XVDpIb6Q=; h=DKIM-Signature:From:To:Subject:Date:Message-ID:MIME-Version; b=jkara6ACAXlaB0QeytMnz/pfAXLSiEXh2xwIsHMG4BZIyoTBvWWcyf7Hwl9nYOFyt7B1iU1V8uMVFm2xV/Ca0btfdu8TKtsNlJFgX26AHTQli21PXhIUTneO6FsH2KzOEMB/N5sOuMyMhAfeuUZLnHOIpuncIqgS61CP4LLqgAw= ARC-Authentication-Results: i=1; server2.sourceware.org Received: from mgamail.intel.com ([198.175.65.13]) by eggs.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from ) id 1rV0BO-0002VP-6M for gcc-patches@gnu.org; Tue, 30 Jan 2024 21:18:35 -0500 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=intel.com; i=@intel.com; q=dns/txt; s=Intel; t=1706667515; x=1738203515; h=from:to:cc:subject:date:message-id:in-reply-to: references:mime-version:content-transfer-encoding; bh=/tI4mAEmWiEwyCi4dXHq1Y2snm9zqK1o3c/XVDpIb6Q=; b=K7VkLfqYcCZwo5LLwXmXKuNntVFDodBQ8syM2jf/bAuSUuAZ3VDfKx8o vPwk3IUNIPw/843gD7gqV9XtfAi7AZlYjMItlXNI8N78E8MP1Rmjz8tU8 GI1JlrpstrArvNXBE3I+FXm2KrRmLq9bA2sb+iCgGyeJW2eTyx7hYul6T 2sGLBYcr3YdjLsB3t+OBQXAIN6YA/apjUfzxyhPmnKvYhfjgglPfG4A2u bN3WK18RNaJ7WXHWvFlh+DfosHeFzepWbnjGUpEaeHYkYuxeQIf+i5qZz 0cO17PmC5UU+nndLhvFuSMFSvZLmDPb2QLBwCL75kc+qSFgIBwBoFgoJ2 g==; X-IronPort-AV: E=McAfee;i="6600,9927,10969"; a="10561931" X-IronPort-AV: E=Sophos;i="6.05,231,1701158400"; d="scan'208";a="10561931" Received: from orsmga003.jf.intel.com ([10.7.209.27]) by orvoesa105.jf.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 30 Jan 2024 18:18:16 -0800 X-ExtLoop1: 1 X-IronPort-AV: E=McAfee;i="6600,9927,10969"; a="737946817" X-IronPort-AV: E=Sophos;i="6.05,231,1701158400"; d="scan'208";a="737946817" Received: from tassilo.jf.intel.com ([10.54.38.190]) by orsmga003-auth.jf.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 30 Jan 2024 18:18:15 -0800 From: Andi Kleen To: gcc-patches@gnu.org Cc: Andi Kleen Subject: [PATCH v3 2/5] C++: Support clang compatible [[musttail]] (PR83324) Date: Tue, 30 Jan 2024 18:17:15 -0800 Message-ID: <20240131021808.151575-3-ak@linux.intel.com> X-Mailer: git-send-email 2.43.0 In-Reply-To: <20240131021808.151575-1-ak@linux.intel.com> References: <20240131021808.151575-1-ak@linux.intel.com> MIME-Version: 1.0 Received-SPF: none client-ip=198.175.65.13; envelope-from=ak@linux.intel.com; helo=mgamail.intel.com X-Spam_score_int: -32 X-Spam_score: -3.3 X-Spam_bar: --- X-Spam_report: (-3.3 / 5.0 requ) BAYES_00=-1.9, DKIMWL_WL_HIGH=-1.292, DKIM_SIGNED=0.1, DKIM_VALID=-0.1, DKIM_VALID_EF=-0.1, SPF_HELO_NONE=0.001, SPF_NONE=0.001, T_SCC_BODY_TEXT_LINE=-0.01 autolearn=ham autolearn_force=no X-Spam_action: no action X-Spam-Status: No, score=-12.2 required=5.0 tests=BAYES_00, DKIMWL_WL_HIGH, DKIM_SIGNED, DKIM_VALID, DKIM_VALID_EF, GIT_PATCH_0, SPF_HELO_PASS, 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: 1789570663763817716 X-GMAIL-MSGID: 1789570663763817716 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 --- gcc/cp/cp-tree.h | 4 ++-- gcc/cp/parser.cc | 28 +++++++++++++++++++++++----- gcc/cp/semantics.cc | 6 +++--- gcc/cp/typeck.cc | 20 ++++++++++++++++++-- 4 files changed, 46 insertions(+), 12 deletions(-) diff --git a/gcc/cp/cp-tree.h b/gcc/cp/cp-tree.h index 60e6dafc5494..bed52e860a00 100644 --- a/gcc/cp/cp-tree.h +++ b/gcc/cp/cp-tree.h @@ -7763,7 +7763,7 @@ extern void finish_while_stmt (tree); extern tree begin_do_stmt (void); extern void finish_do_body (tree); extern void finish_do_stmt (tree, tree, bool, tree, bool); -extern tree finish_return_stmt (tree); +extern tree finish_return_stmt (tree, bool = false); extern tree begin_for_scope (tree *); extern tree begin_for_stmt (tree, tree); extern void finish_init_stmt (tree); @@ -8275,7 +8275,7 @@ extern tree composite_pointer_type (const op_location_t &, tsubst_flags_t); extern tree merge_types (tree, tree); extern tree strip_array_domain (tree); -extern tree check_return_expr (tree, bool *, bool *); +extern tree check_return_expr (tree, bool *, bool *, bool); extern tree spaceship_type (tree, tsubst_flags_t = tf_warning_or_error); extern tree genericize_spaceship (location_t, tree, tree, tree); extern tree cp_build_binary_op (const op_location_t &, diff --git a/gcc/cp/parser.cc b/gcc/cp/parser.cc index 3748ccd49ff3..5a32804c0201 100644 --- a/gcc/cp/parser.cc +++ b/gcc/cp/parser.cc @@ -2462,7 +2462,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 *, bool = false); static void cp_parser_declaration_statement (cp_parser *); @@ -12719,9 +12719,27 @@ cp_parser_statement (cp_parser* parser, tree in_statement_expr, NULL_TREE, false); break; + case RID_RETURN: + { + bool musttail_p = false; + std_attrs = process_stmt_hotness_attribute (std_attrs, attrs_loc); + if (lookup_attribute ("", "musttail", std_attrs)) + { + musttail_p = true; + std_attrs = remove_attribute ("", "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); + } + statement = cp_parser_jump_statement (parser, musttail_p); + } + 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); @@ -14767,7 +14785,7 @@ cp_parser_init_statement (cp_parser *parser, tree *decl) return false; } -/* Parse a jump-statement. +/* Parse a jump-statement. MUSTTAIL_P indicates a musttail attribute. jump-statement: break ; @@ -14785,7 +14803,7 @@ cp_parser_init_statement (cp_parser *parser, tree *decl) 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, bool musttail_p) { tree statement = error_mark_node; cp_token *token; @@ -14869,7 +14887,7 @@ cp_parser_jump_statement (cp_parser* parser) else if (FNDECL_USED_AUTO (current_function_decl) && in_discarded_stmt) /* Don't deduce from a discarded return statement. */; else - statement = finish_return_stmt (expr); + statement = finish_return_stmt (expr, musttail_p); /* Look for the final `;'. */ cp_parser_require (parser, CPP_SEMICOLON, RT_SEMICOLON); } diff --git a/gcc/cp/semantics.cc b/gcc/cp/semantics.cc index 3299e2704465..a277f70ea0fd 100644 --- a/gcc/cp/semantics.cc +++ b/gcc/cp/semantics.cc @@ -1324,16 +1324,16 @@ finish_do_stmt (tree cond, tree do_stmt, bool ivdep, tree unroll, } /* Finish a return-statement. The EXPRESSION returned, if any, is as - indicated. */ + indicated. MUSTTAIL_P indicates a mustcall attribute. */ tree -finish_return_stmt (tree expr) +finish_return_stmt (tree expr, bool musttail_p) { tree r; bool no_warning; bool dangling; - expr = check_return_expr (expr, &no_warning, &dangling); + expr = check_return_expr (expr, &no_warning, &dangling, musttail_p); if (error_operand_p (expr) || (flag_openmp && !check_omp_return ())) diff --git a/gcc/cp/typeck.cc b/gcc/cp/typeck.cc index a15eda3f5f8c..8c116e3b4f4c 100644 --- a/gcc/cp/typeck.cc +++ b/gcc/cp/typeck.cc @@ -11028,10 +11028,12 @@ maybe_warn_pessimizing_move (tree expr, tree type, bool return_p) the DECL_RESULT for the function. Set *NO_WARNING to true if code reaches end of non-void function warning shouldn't be issued on this RETURN_EXPR. Set *DANGLING to true if code returns the - address of a local variable. */ + address of a local variable. MUSTTAIL_P indicates a musttail + return. */ tree -check_return_expr (tree retval, bool *no_warning, bool *dangling) +check_return_expr (tree retval, bool *no_warning, bool *dangling, + bool musttail_p) { tree result; /* The type actually returned by the function. */ @@ -11045,6 +11047,20 @@ check_return_expr (tree retval, bool *no_warning, bool *dangling) *no_warning = false; *dangling = false; + if (musttail_p) + { + if (TREE_CODE (retval) == TARGET_EXPR + && TREE_CODE (TARGET_EXPR_INITIAL (retval)) == CALL_EXPR) + CALL_EXPR_MUST_TAIL_CALL (TARGET_EXPR_INITIAL (retval)) = 1; + else if (TREE_CODE (retval) != CALL_EXPR) + { + error_at (loc, "cannot tail-call: return value must be a call"); + return error_mark_node; + } + else + CALL_EXPR_MUST_TAIL_CALL (retval) = 1; + } + /* A `volatile' function is one that isn't supposed to return, ever. (This is a G++ extension, used to get better code for functions that call the `volatile' function.) */