From patchwork Tue Nov 15 12:33:06 2016 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Richard Sandiford X-Patchwork-Id: 695013 Return-Path: X-Original-To: incoming@patchwork.ozlabs.org Delivered-To: patchwork-incoming@bilbo.ozlabs.org Received: from sourceware.org (server1.sourceware.org [209.132.180.131]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by ozlabs.org (Postfix) with ESMTPS id 3tJ6Hs4zBlz9t0X for ; Tue, 15 Nov 2016 23:33:29 +1100 (AEDT) Authentication-Results: ozlabs.org; dkim=pass (1024-bit key; unprotected) header.d=gcc.gnu.org header.i=@gcc.gnu.org header.b="CNE5IUqS"; dkim-atps=neutral DomainKey-Signature: a=rsa-sha1; c=nofws; d=gcc.gnu.org; h=list-id :list-unsubscribe:list-archive:list-post:list-help:sender:from :to:subject:date:message-id:mime-version:content-type; q=dns; s= default; b=SV3pnija/IdxM3Ozud4TMUFCqBo8FgJHmJuOUGyVpyEN2v//kQK3p FUIImeGnI3EjEvQvS69AbKRBepek86URgETDeA5Iiv1q9uXvqU7Wy5mXmIYnKukg 84rp8uHpk95ukJtaCMcywipfaAFfW6tQGQIYT5hD4Hd+KBnLtRpL4U= DKIM-Signature: v=1; a=rsa-sha1; c=relaxed; d=gcc.gnu.org; h=list-id :list-unsubscribe:list-archive:list-post:list-help:sender:from :to:subject:date:message-id:mime-version:content-type; s= default; bh=2obg4g+obK+7uW4OzojNl1+Z6D0=; b=CNE5IUqSMuydYOEMESfM UQsZBgAHfs9tlL7WT09ABdgnqdp5H0d4Lfs1yGeVO52BoTCZ/VMaVLnaeoudcbGL LxrpA+ibrHVMKStVUVTAIt70FSFhP8yD4txk06CTwaq2koAWVEsPEtoVDs2tv7up 8hK+FGWUgNb6pfnCHfZJQKw= Received: (qmail 96993 invoked by alias); 15 Nov 2016 12:33:21 -0000 Mailing-List: contact gcc-patches-help@gcc.gnu.org; run by ezmlm Precedence: bulk List-Id: List-Unsubscribe: List-Archive: List-Post: List-Help: Sender: gcc-patches-owner@gcc.gnu.org Delivered-To: mailing list gcc-patches@gcc.gnu.org Received: (qmail 96976 invoked by uid 89); 15 Nov 2016 12:33:20 -0000 Authentication-Results: sourceware.org; auth=none X-Virus-Found: No X-Spam-SWARE-Status: No, score=-4.7 required=5.0 tests=BAYES_00, RP_MATCHES_RCVD autolearn=ham version=3.3.2 spammy=zero_extract, our X-HELO: foss.arm.com Received: from foss.arm.com (HELO foss.arm.com) (217.140.101.70) by sourceware.org (qpsmtpd/0.93/v0.84-503-g423c35a) with ESMTP; Tue, 15 Nov 2016 12:33:10 +0000 Received: from usa-sjc-imap-foss1.foss.arm.com (unknown [10.72.51.249]) by usa-sjc-mx-foss1.foss.arm.com (Postfix) with ESMTP id 9B375AD7; Tue, 15 Nov 2016 04:33:08 -0800 (PST) Received: from localhost (e105548-lin.manchester.arm.com [10.45.32.67]) by usa-sjc-imap-foss1.foss.arm.com (Postfix) with ESMTPSA id 249B93F218 for ; Tue, 15 Nov 2016 04:33:08 -0800 (PST) From: Richard Sandiford To: gcc-patches@gcc.gnu.org Mail-Followup-To: gcc-patches@gcc.gnu.org, richard.sandiford@arm.com Subject: An alternative fix for PR70944 Date: Tue, 15 Nov 2016 12:33:06 +0000 Message-ID: <87d1hw53el.fsf@e105548-lin.cambridge.arm.com> User-Agent: Gnus/5.130012 (Ma Gnus v0.12) Emacs/24.3 (gnu/linux) MIME-Version: 1.0 The transformations made by make_compound_operation apply only to scalar integer modes. The fix for PR70944 had enforced that by returning early for vector modes at the top of the function. However, the function is supposed to be recursive, so we should continue to look at integer suboperands even if the outer operation is a vector one. This patch instead splits out the non-recursive parts of make_compound_operation into a subroutine and checks that the mode is a scalar integer before calling it. The patch was originally written to help with the later conversion to static type checking of mode classes, but it also happened to reenable optimisation of things like vec_duplicate operands. Note that the gen_lowparts in the PLUS and MINUS cases were redundant, since new_rtx already had mode "mode" at those points. Tested on aarch64-linux-gnu and x86_64-linux-gnu. OK to install? Thanks, Richard [ This patch is part of the SVE series posted here: https://gcc.gnu.org/ml/gcc/2016-11/msg00030.html ] gcc/ 2016-11-15 Richard Sandiford Alan Hayward David Sherwood * combine.c (maybe_swap_commutative_operands): New function. (combine_simplify_rtx): Use it. (make_compound_operation_int): New function, split out of... (make_compound_operation): ...here. Use maybe_swap_commutative_operands for both. diff --git a/gcc/combine.c b/gcc/combine.c index 66f628f..0665f38 100644 --- a/gcc/combine.c +++ b/gcc/combine.c @@ -5479,6 +5479,21 @@ subst (rtx x, rtx from, rtx to, int in_dest, int in_cond, int unique_copy) return x; } +/* If X is a commutative operation whose operands are not in the canonical + order, use substitutions to swap them. */ + +static void +maybe_swap_commutative_operands (rtx x) +{ + if (COMMUTATIVE_ARITH_P (x) + && swap_commutative_operands_p (XEXP (x, 0), XEXP (x, 1))) + { + rtx temp = XEXP (x, 0); + SUBST (XEXP (x, 0), XEXP (x, 1)); + SUBST (XEXP (x, 1), temp); + } +} + /* Simplify X, a piece of RTL. We just operate on the expression at the outer level; call `subst' to simplify recursively. Return the new expression. @@ -5498,13 +5513,7 @@ combine_simplify_rtx (rtx x, machine_mode op0_mode, int in_dest, /* If this is a commutative operation, put a constant last and a complex expression first. We don't need to do this for comparisons here. */ - if (COMMUTATIVE_ARITH_P (x) - && swap_commutative_operands_p (XEXP (x, 0), XEXP (x, 1))) - { - temp = XEXP (x, 0); - SUBST (XEXP (x, 0), XEXP (x, 1)); - SUBST (XEXP (x, 1), temp); - } + maybe_swap_commutative_operands (x); /* Try to fold this expression in case we have constants that weren't present before. */ @@ -7747,55 +7756,38 @@ extract_left_shift (rtx x, int count) return 0; } -/* Look at the expression rooted at X. Look for expressions - equivalent to ZERO_EXTRACT, SIGN_EXTRACT, ZERO_EXTEND, SIGN_EXTEND. - Form these expressions. - - Return the new rtx, usually just X. +/* Subroutine of make_compound_operation. *X_PTR is the rtx at the current + level of the expression and MODE is its mode. IN_CODE is as for + make_compound_operation. *NEXT_CODE_PTR is the value of IN_CODE + that should be used when recursing on operands of *X_PTR. - Also, for machines like the VAX that don't have logical shift insns, - try to convert logical to arithmetic shift operations in cases where - they are equivalent. This undoes the canonicalizations to logical - shifts done elsewhere. + There are two possible actions: - We try, as much as possible, to re-use rtl expressions to save memory. + - Return null. This tells the caller to recurse on *X_PTR with IN_CODE + equal to *NEXT_CODE_PTR, after which *X_PTR holds the final value. - IN_CODE says what kind of expression we are processing. Normally, it is - SET. In a memory address it is MEM. When processing the arguments of - a comparison or a COMPARE against zero, it is COMPARE, or EQ if more - precisely it is an equality comparison against zero. */ + - Return a new rtx, which the caller returns directly. */ -rtx -make_compound_operation (rtx x, enum rtx_code in_code) +static rtx +make_compound_operation_int (machine_mode mode, rtx *x_ptr, + enum rtx_code in_code, + enum rtx_code *next_code_ptr) { + rtx x = *x_ptr; + enum rtx_code next_code = *next_code_ptr; enum rtx_code code = GET_CODE (x); - machine_mode mode = GET_MODE (x); int mode_width = GET_MODE_PRECISION (mode); rtx rhs, lhs; - enum rtx_code next_code; - int i, j; rtx new_rtx = 0; + int i; rtx tem; - const char *fmt; bool equality_comparison = false; - /* PR rtl-optimization/70944. */ - if (VECTOR_MODE_P (mode)) - return x; - - /* Select the code to be used in recursive calls. Once we are inside an - address, we stay there. If we have a comparison, set to COMPARE, - but once inside, go back to our default of SET. */ - if (in_code == EQ) { equality_comparison = true; in_code = COMPARE; } - next_code = (code == MEM ? MEM - : ((code == COMPARE || COMPARISON_P (x)) - && XEXP (x, 1) == const0_rtx) ? COMPARE - : in_code == COMPARE ? SET : in_code); /* Process depending on the code of this operation. If NEW is set nonzero, it will be returned. */ @@ -7807,8 +7799,7 @@ make_compound_operation (rtx x, enum rtx_code in_code) an address. */ if (in_code == MEM && CONST_INT_P (XEXP (x, 1)) && INTVAL (XEXP (x, 1)) < HOST_BITS_PER_WIDE_INT - && INTVAL (XEXP (x, 1)) >= 0 - && SCALAR_INT_MODE_P (mode)) + && INTVAL (XEXP (x, 1)) >= 0) { HOST_WIDE_INT count = INTVAL (XEXP (x, 1)); HOST_WIDE_INT multval = HOST_WIDE_INT_1 << count; @@ -7829,8 +7820,7 @@ make_compound_operation (rtx x, enum rtx_code in_code) rhs = XEXP (x, 1); lhs = make_compound_operation (lhs, next_code); rhs = make_compound_operation (rhs, next_code); - if (GET_CODE (lhs) == MULT && GET_CODE (XEXP (lhs, 0)) == NEG - && SCALAR_INT_MODE_P (mode)) + if (GET_CODE (lhs) == MULT && GET_CODE (XEXP (lhs, 0)) == NEG) { tem = simplify_gen_binary (MULT, mode, XEXP (XEXP (lhs, 0), 0), XEXP (lhs, 1)); @@ -7849,22 +7839,20 @@ make_compound_operation (rtx x, enum rtx_code in_code) { SUBST (XEXP (x, 0), lhs); SUBST (XEXP (x, 1), rhs); - goto maybe_swap; } - x = gen_lowpart (mode, new_rtx); - goto maybe_swap; + maybe_swap_commutative_operands (x); + return x; case MINUS: lhs = XEXP (x, 0); rhs = XEXP (x, 1); lhs = make_compound_operation (lhs, next_code); rhs = make_compound_operation (rhs, next_code); - if (GET_CODE (rhs) == MULT && GET_CODE (XEXP (rhs, 0)) == NEG - && SCALAR_INT_MODE_P (mode)) + if (GET_CODE (rhs) == MULT && GET_CODE (XEXP (rhs, 0)) == NEG) { tem = simplify_gen_binary (MULT, mode, XEXP (XEXP (rhs, 0), 0), XEXP (rhs, 1)); - new_rtx = simplify_gen_binary (PLUS, mode, tem, lhs); + return simplify_gen_binary (PLUS, mode, tem, lhs); } else if (GET_CODE (rhs) == MULT && (CONST_INT_P (XEXP (rhs, 1)) && INTVAL (XEXP (rhs, 1)) < 0)) @@ -7873,7 +7861,7 @@ make_compound_operation (rtx x, enum rtx_code in_code) simplify_gen_unary (NEG, mode, XEXP (rhs, 1), mode)); - new_rtx = simplify_gen_binary (PLUS, mode, tem, lhs); + return simplify_gen_binary (PLUS, mode, tem, lhs); } else { @@ -7881,7 +7869,6 @@ make_compound_operation (rtx x, enum rtx_code in_code) SUBST (XEXP (x, 1), rhs); return x; } - return gen_lowpart (mode, new_rtx); case AND: /* If the second operand is not a constant, we can't do anything @@ -8162,15 +8149,60 @@ make_compound_operation (rtx x, enum rtx_code in_code) } if (new_rtx) + *x_ptr = gen_lowpart (mode, new_rtx); + *next_code_ptr = next_code; + return NULL_RTX; +} + +/* Look at the expression rooted at X. Look for expressions + equivalent to ZERO_EXTRACT, SIGN_EXTRACT, ZERO_EXTEND, SIGN_EXTEND. + Form these expressions. + + Return the new rtx, usually just X. + + Also, for machines like the VAX that don't have logical shift insns, + try to convert logical to arithmetic shift operations in cases where + they are equivalent. This undoes the canonicalizations to logical + shifts done elsewhere. + + We try, as much as possible, to re-use rtl expressions to save memory. + + IN_CODE says what kind of expression we are processing. Normally, it is + SET. In a memory address it is MEM. When processing the arguments of + a comparison or a COMPARE against zero, it is COMPARE, or EQ if more + precisely it is an equality comparison against zero. */ + +rtx +make_compound_operation (rtx x, enum rtx_code in_code) +{ + enum rtx_code code = GET_CODE (x); + const char *fmt; + int i, j; + enum rtx_code next_code; + rtx new_rtx, tem; + + /* Select the code to be used in recursive calls. Once we are inside an + address, we stay there. If we have a comparison, set to COMPARE, + but once inside, go back to our default of SET. */ + + next_code = (code == MEM ? MEM + : ((code == COMPARE || COMPARISON_P (x)) + && XEXP (x, 1) == const0_rtx) ? COMPARE + : in_code == COMPARE || in_code == EQ ? SET : in_code); + + if (SCALAR_INT_MODE_P (GET_MODE (x))) { - x = gen_lowpart (mode, new_rtx); + rtx new_rtx = make_compound_operation_int (GET_MODE (x), &x, + in_code, &next_code); + if (new_rtx) + return new_rtx; code = GET_CODE (x); } /* Now recursively process each operand of this operation. We need to handle ZERO_EXTEND specially so that we don't lose track of the inner mode. */ - if (GET_CODE (x) == ZERO_EXTEND) + if (code == ZERO_EXTEND) { new_rtx = make_compound_operation (XEXP (x, 0), next_code); tem = simplify_const_unary_operation (ZERO_EXTEND, GET_MODE (x), @@ -8195,17 +8227,7 @@ make_compound_operation (rtx x, enum rtx_code in_code) SUBST (XVECEXP (x, i, j), new_rtx); } - maybe_swap: - /* If this is a commutative operation, the changes to the operands - may have made it noncanonical. */ - if (COMMUTATIVE_ARITH_P (x) - && swap_commutative_operands_p (XEXP (x, 0), XEXP (x, 1))) - { - tem = XEXP (x, 0); - SUBST (XEXP (x, 0), XEXP (x, 1)); - SUBST (XEXP (x, 1), tem); - } - + maybe_swap_commutative_operands (x); return x; }