From patchwork Wed Aug 26 08:14:16 2020 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Iain Buclaw X-Patchwork-Id: 1351697 Return-Path: X-Original-To: incoming@patchwork.ozlabs.org Delivered-To: patchwork-incoming@bilbo.ozlabs.org Authentication-Results: ozlabs.org; spf=pass (sender SPF authorized) smtp.mailfrom=gcc.gnu.org (client-ip=2620:52:3:1:0:246e:9693:128c; helo=sourceware.org; envelope-from=gcc-patches-bounces@gcc.gnu.org; receiver=) Authentication-Results: ozlabs.org; dmarc=none (p=none dis=none) header.from=gcc.gnu.org Authentication-Results: ozlabs.org; dkim=pass (1024-bit key; unprotected) header.d=gcc.gnu.org header.i=@gcc.gnu.org header.a=rsa-sha256 header.s=default header.b=ppKlkNIA; dkim-atps=neutral Received: from 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 RSA-PSS (4096 bits) server-digest SHA256) (No client certificate requested) by ozlabs.org (Postfix) with ESMTPS id 4BbzDH3TGzz9sSJ for ; Wed, 26 Aug 2020 18:14:39 +1000 (AEST) Received: from server2.sourceware.org (localhost [IPv6:::1]) by sourceware.org (Postfix) with ESMTP id E17013861026; Wed, 26 Aug 2020 08:14:35 +0000 (GMT) DKIM-Filter: OpenDKIM Filter v2.11.0 sourceware.org E17013861026 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gcc.gnu.org; s=default; t=1598429675; bh=vuSWkzeYXwhkE+hwdkJ4gLzC0Y7ZDH0t/Lz5KcoqeEQ=; h=To:Subject:Date:List-Id:List-Unsubscribe:List-Archive:List-Post: List-Help:List-Subscribe:From:Reply-To:From; b=ppKlkNIAxuhkwRUALO4yC85Bt1Iug1eiO+fkexlItJoeLEf7qtzEQoNCmi+LWXG7c K+qOKZiKkulI6Zex616dfyt374t3UPlQ0JKPrknxceVVFkvnly3fQbIIS4Dh4QthB4 5R/Zu6JYZApLUDbY/MK//XdumfoZ1P3xboaIfPoQ= X-Original-To: gcc-patches@gcc.gnu.org Delivered-To: gcc-patches@gcc.gnu.org Received: from mout-p-102.mailbox.org (mout-p-102.mailbox.org [IPv6:2001:67c:2050::465:102]) by sourceware.org (Postfix) with ESMTPS id 642F53857C4D for ; Wed, 26 Aug 2020 08:14:32 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.3.2 sourceware.org 642F53857C4D Received: from smtp1.mailbox.org (smtp1.mailbox.org [80.241.60.240]) (using TLSv1.2 with cipher ECDHE-RSA-CHACHA20-POLY1305 (256/256 bits)) (No client certificate requested) by mout-p-102.mailbox.org (Postfix) with ESMTPS id 4BbzD66l7pzKmXL; Wed, 26 Aug 2020 10:14:30 +0200 (CEST) X-Virus-Scanned: amavisd-new at heinlein-support.de Received: from smtp1.mailbox.org ([80.241.60.240]) by spamfilter06.heinlein-hosting.de (spamfilter06.heinlein-hosting.de [80.241.56.125]) (amavisd-new, port 10030) with ESMTP id xgxqi4UlGxQk; Wed, 26 Aug 2020 10:14:18 +0200 (CEST) To: gcc-patches@gcc.gnu.org Subject: [committed] d: Move lowering of each tree node to separate functions Date: Wed, 26 Aug 2020 10:14:16 +0200 Message-Id: <20200826081416.450861-1-ibuclaw@gdcproject.org> MIME-Version: 1.0 X-MBO-SPAM-Probability: *** X-Rspamd-Score: 3.72 / 15.00 / 15.00 X-Rspamd-Queue-Id: D09FC179C X-Rspamd-UID: 94474b X-Spam-Status: No, score=-15.4 required=5.0 tests=BAYES_00, DKIM_SIGNED, DKIM_VALID, DKIM_VALID_AU, DKIM_VALID_EF, GIT_PATCH_0, RCVD_IN_DNSWL_NONE, SPF_HELO_NONE, SPF_PASS, TXREP autolearn=ham autolearn_force=no version=3.4.2 X-Spam-Checker-Version: SpamAssassin 3.4.2 (2018-09-13) 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: Iain Buclaw via Gcc-patches From: Iain Buclaw Reply-To: Iain Buclaw Errors-To: gcc-patches-bounces@gcc.gnu.org Sender: "Gcc-patches" Hi, This patch moves each lowering in d_gimplify_expr to separate functions. Bootstrapped and regression tested on x86_64-linux-gnu/-m32/-mx32, committed to mainline. Regards Iain --- gcc/d/ChangeLog: * d-gimplify.cc (d_gimplify_expr): Move lowering of each tree node to separate functions. (d_gimplify_modify_expr): New function. (d_gimplify_addr_expr): New function. (d_gimplify_call_expr): New function. (d_gimplify_unsigned_rshift_expr): New function. --- gcc/d/d-gimplify.cc | 210 +++++++++++++++++++++++++------------------- 1 file changed, 119 insertions(+), 91 deletions(-) diff --git a/gcc/d/d-gimplify.cc b/gcc/d/d-gimplify.cc index 6b07104daf8..bf2718eb9cf 100644 --- a/gcc/d/d-gimplify.cc +++ b/gcc/d/d-gimplify.cc @@ -66,119 +66,147 @@ empty_modify_p (tree type, tree op) return empty_aggregate_p (type); } -/* Implements the lang_hooks.gimplify_expr routine for language D. - Do gimplification of D specific expression trees in EXPR_P. */ +/* Gimplify assignment from an INIT_EXPR or MODIFY_EXPR. */ -int -d_gimplify_expr (tree *expr_p, gimple_seq *pre_p, - gimple_seq *post_p ATTRIBUTE_UNUSED) +static gimplify_status +d_gimplify_modify_expr (tree *expr_p, gimple_seq *pre_p, gimple_seq *post_p) { - tree_code code = TREE_CODE (*expr_p); - enum gimplify_status ret = GS_UNHANDLED; - tree op0, op1; - tree type; + tree op0 = TREE_OPERAND (*expr_p, 0); + tree op1 = TREE_OPERAND (*expr_p, 1); - switch (code) + if (error_operand_p (op0) || error_operand_p (op1)) + return GS_UNHANDLED; + + /* Remove any copies of empty aggregates. */ + if (empty_modify_p (TREE_TYPE (op0), op1)) { - case INIT_EXPR: - case MODIFY_EXPR: - op0 = TREE_OPERAND (*expr_p, 0); - op1 = TREE_OPERAND (*expr_p, 1); + gimplify_expr (&TREE_OPERAND (*expr_p, 0), pre_p, post_p, + is_gimple_lvalue, fb_lvalue); - if (!error_operand_p (op0) && !error_operand_p (op1) - && (AGGREGATE_TYPE_P (TREE_TYPE (op0)) - || AGGREGATE_TYPE_P (TREE_TYPE (op1))) - && !useless_type_conversion_p (TREE_TYPE (op1), TREE_TYPE (op0))) - { - /* If the back end isn't clever enough to know that the lhs and rhs - types are the same, add an explicit conversion. */ - TREE_OPERAND (*expr_p, 1) = build1 (VIEW_CONVERT_EXPR, - TREE_TYPE (op0), op1); - ret = GS_OK; - } - else if (empty_modify_p (TREE_TYPE (op0), op1)) - { - /* Remove any copies of empty aggregates. */ - gimplify_expr (&TREE_OPERAND (*expr_p, 0), pre_p, post_p, - is_gimple_lvalue, fb_lvalue); + if (TREE_SIDE_EFFECTS (op1)) + gimplify_and_add (op1, pre_p); - if (TREE_SIDE_EFFECTS (op1)) - gimplify_and_add (op1, pre_p); + *expr_p = TREE_OPERAND (*expr_p, 0); + return GS_OK; + } - *expr_p = TREE_OPERAND (*expr_p, 0); - ret = GS_OK; - } - break; + /* If the back end isn't clever enough to know that the lhs and rhs + types are the same, add an explicit conversion. */ + if ((AGGREGATE_TYPE_P (TREE_TYPE (op0)) || AGGREGATE_TYPE_P (TREE_TYPE (op1))) + && !useless_type_conversion_p (TREE_TYPE (op1), TREE_TYPE (op0))) + { + TREE_OPERAND (*expr_p, 1) = build1 (VIEW_CONVERT_EXPR, + TREE_TYPE (op0), op1); + return GS_OK; + } - case ADDR_EXPR: - op0 = TREE_OPERAND (*expr_p, 0); - /* Constructors are not lvalues, so make them one. */ - if (TREE_CODE (op0) == CONSTRUCTOR) + return GS_UNHANDLED; +} + +/* Gimplify an ADDR_EXPR node. */ + +static gimplify_status +d_gimplify_addr_expr (tree *expr_p) +{ + tree op0 = TREE_OPERAND (*expr_p, 0); + /* Constructors are not lvalues, so make them one. */ + if (TREE_CODE (op0) == CONSTRUCTOR) + { + TREE_OPERAND (*expr_p, 0) = force_target_expr (op0); + return GS_OK; + } + + return GS_UNHANDLED; +} + +/* Gimplify a CALL_EXPR node. */ + +static gimplify_status +d_gimplify_call_expr (tree *expr_p, gimple_seq *pre_p) +{ + if (CALL_EXPR_ARGS_ORDERED (*expr_p)) + { + /* Strictly evaluate all arguments from left to right. */ + int nargs = call_expr_nargs (*expr_p); + location_t loc = EXPR_LOC_OR_LOC (*expr_p, input_location); + + /* No need to enforce evaluation order if only one argument. */ + if (nargs < 2) + return GS_UNHANDLED; + + /* Or if all arguments are already free of side-effects. */ + bool has_side_effects = false; + for (int i = 0; i < nargs; i++) { - TREE_OPERAND (*expr_p, 0) = force_target_expr (op0); - ret = GS_OK; + if (TREE_SIDE_EFFECTS (CALL_EXPR_ARG (*expr_p, i))) + { + has_side_effects = true; + break; + } } - break; - case CALL_EXPR: - if (CALL_EXPR_ARGS_ORDERED (*expr_p)) + if (!has_side_effects) + return GS_UNHANDLED; + + /* Leave the last argument for gimplify_call_expr. */ + for (int i = 0; i < nargs - 1; i++) { - /* Strictly evaluate all arguments from left to right. */ - int nargs = call_expr_nargs (*expr_p); - location_t loc = EXPR_LOC_OR_LOC (*expr_p, input_location); + tree new_arg = CALL_EXPR_ARG (*expr_p, i); - /* No need to enforce evaluation order if only one argument. */ - if (nargs < 2) - break; + /* If argument has a side-effect, gimplify_arg will handle it. */ + if (gimplify_arg (&new_arg, pre_p, loc) == GS_ERROR) + return GS_ERROR; - /* Or if all arguments are already free of side-effects. */ - bool has_side_effects = false; - for (int i = 0; i < nargs; i++) - { - if (TREE_SIDE_EFFECTS (CALL_EXPR_ARG (*expr_p, i))) - { - has_side_effects = true; - break; - } - } + /* Even if an argument itself doesn't have any side-effects, it + might be altered by another argument in the list. */ + if (new_arg == CALL_EXPR_ARG (*expr_p, i) + && !really_constant_p (new_arg)) + new_arg = get_formal_tmp_var (new_arg, pre_p); - if (!has_side_effects) - break; + CALL_EXPR_ARG (*expr_p, i) = new_arg; + } - /* Leave the last argument for gimplify_call_expr. */ - for (int i = 0; i < nargs - 1; i++) - { - tree new_arg = CALL_EXPR_ARG (*expr_p, i); + return GS_OK; + } - /* If argument has a side-effect, gimplify_arg will handle it. */ - if (gimplify_arg (&new_arg, pre_p, loc) == GS_ERROR) - ret = GS_ERROR; + return GS_UNHANDLED; +} - /* Even if an argument itself doesn't have any side-effects, it - might be altered by another argument in the list. */ - if (new_arg == CALL_EXPR_ARG (*expr_p, i) - && !really_constant_p (new_arg)) - new_arg = get_formal_tmp_var (new_arg, pre_p); +/* Gimplify an UNSIGNED_RSHIFT_EXPR node. */ - CALL_EXPR_ARG (*expr_p, i) = new_arg; - } +static gimplify_status +d_gimplify_unsigned_rshift_expr (tree *expr_p) +{ + /* Convert op0 to an unsigned type. */ + tree op0 = TREE_OPERAND (*expr_p, 0); + tree op1 = TREE_OPERAND (*expr_p, 1); + tree type = d_unsigned_type (TREE_TYPE (op0)); + + *expr_p = convert (TREE_TYPE (*expr_p), + build2 (RSHIFT_EXPR, type, convert (type, op0), op1)); + return GS_OK; +} - if (ret != GS_ERROR) - ret = GS_OK; - } - break; +/* Implements the lang_hooks.gimplify_expr routine for language D. + Do gimplification of D specific expression trees in EXPR_P. */ - case UNSIGNED_RSHIFT_EXPR: - /* Convert op0 to an unsigned type. */ - op0 = TREE_OPERAND (*expr_p, 0); - op1 = TREE_OPERAND (*expr_p, 1); +int +d_gimplify_expr (tree *expr_p, gimple_seq *pre_p, gimple_seq *post_p) +{ + switch (TREE_CODE (*expr_p)) + { + case INIT_EXPR: + case MODIFY_EXPR: + return d_gimplify_modify_expr (expr_p, pre_p, post_p); - type = d_unsigned_type (TREE_TYPE (op0)); + case ADDR_EXPR: + return d_gimplify_addr_expr (expr_p); - *expr_p = convert (TREE_TYPE (*expr_p), - build2 (RSHIFT_EXPR, type, convert (type, op0), op1)); - ret = GS_OK; - break; + case CALL_EXPR: + return d_gimplify_call_expr (expr_p, pre_p); + + case UNSIGNED_RSHIFT_EXPR: + return d_gimplify_unsigned_rshift_expr (expr_p); case FLOAT_MOD_EXPR: gcc_unreachable (); @@ -187,5 +215,5 @@ d_gimplify_expr (tree *expr_p, gimple_seq *pre_p, break; } - return ret; + return GS_UNHANDLED; }