From patchwork Tue Dec 11 10:29:56 2018 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Richard Biener X-Patchwork-Id: 1010999 Return-Path: X-Original-To: incoming@patchwork.ozlabs.org Delivered-To: patchwork-incoming@bilbo.ozlabs.org Authentication-Results: ozlabs.org; spf=pass (mailfrom) smtp.mailfrom=gcc.gnu.org (client-ip=209.132.180.131; helo=sourceware.org; envelope-from=gcc-patches-return-492081-incoming=patchwork.ozlabs.org@gcc.gnu.org; receiver=) Authentication-Results: ozlabs.org; dmarc=none (p=none dis=none) header.from=suse.de Authentication-Results: ozlabs.org; dkim=pass (1024-bit key; unprotected) header.d=gcc.gnu.org header.i=@gcc.gnu.org header.b="iJ7qzzDV"; dkim-atps=neutral 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 43Dbnm2tVfz9s47 for ; Tue, 11 Dec 2018 21:31:07 +1100 (AEDT) DomainKey-Signature: a=rsa-sha1; c=nofws; d=gcc.gnu.org; h=list-id :list-unsubscribe:list-archive:list-post:list-help:sender:date :from:to:subject:message-id:mime-version:content-type; q=dns; s= default; b=TEOuo8XmVzIt0tQeG/gm2fi3K8T0TMlmu0LE0QOmQ/oTvP8UhoKCt RW9pxhfqS9IuxLnOzzFto2qs6ZInPfwJ0vFOjvev6WXI54bZ42VqzdPGRrkk6ejx bsi37+f8QTKty1pg+dJfPPfDXfIA7npmyCzhzZYzXwEj2JU80TxRoM= 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:date :from:to:subject:message-id:mime-version:content-type; s= default; bh=A/U7z8RH4Ok8SixsFP5Qyalsj98=; b=iJ7qzzDVvKwiMZ6TMiMg c5LS1+FFHB2vuI70VlBsw5W3tHd/dnQyBo2c6T7uTtWQR7aS9jWmhPjkSBp2Ibe9 lCzd/qQhpoPhIuLeZG/YbaB5bHebJcGUHbnYsYzCeecGShm3SxBBfaCU5B4xNL+E kKL+hjc7XpLDLmY5GEucZKM= Received: (qmail 49939 invoked by alias); 11 Dec 2018 10:30:57 -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 49544 invoked by uid 89); 11 Dec 2018 10:30:22 -0000 Authentication-Results: sourceware.org; auth=none X-Spam-SWARE-Status: No, score=-11.9 required=5.0 tests=BAYES_00, GIT_PATCH_2, GIT_PATCH_3, SPF_PASS autolearn=unavailable version=3.3.2 spammy=behave, splits X-HELO: mx1.suse.de Received: from mx2.suse.de (HELO mx1.suse.de) (195.135.220.15) by sourceware.org (qpsmtpd/0.93/v0.84-503-g423c35a) with ESMTP; Tue, 11 Dec 2018 10:29:58 +0000 Received: from relay1.suse.de (unknown [195.135.220.254]) by mx1.suse.de (Postfix) with ESMTP id 3ACF4AD52 for ; Tue, 11 Dec 2018 10:29:56 +0000 (UTC) Date: Tue, 11 Dec 2018 11:29:56 +0100 (CET) From: Richard Biener To: gcc-patches@gcc.gnu.org Subject: [PATCH] Rip out rhs-to-tree from tree-affine.c Message-ID: User-Agent: Alpine 2.20 (LSU 67 2015-01-07) MIME-Version: 1.0 After the previous cleanup the following is more straight-forward now. This should make tree-affine behave wrt the "new" GIMPLE world. Bootstrapped and tested on x86_64-unknown-linux-gnu, now making sure there are no codegen changes as expected. Richard. 2018-12-11 Richard Biener * tree-affine.c (expr_to_aff_combination): New function split out from... (tree_to_aff_combination): ... here. (aff_combination_expand): Avoid building a GENERIC tree. Index: gcc/tree-affine.c =================================================================== --- gcc/tree-affine.c (revision 266956) +++ gcc/tree-affine.c (working copy) @@ -259,101 +259,56 @@ aff_combination_convert (aff_tree *comb, } } -/* Splits EXPR into an affine combination of parts. */ +/* Tries to handle OP0 CODE OP1 as affine combination of parts. Returns + true when that was successful and returns the combination in COMB. */ -void -tree_to_aff_combination (tree expr, tree type, aff_tree *comb) +static bool +expr_to_aff_combination (aff_tree *comb, tree_code code, tree type, + tree op0, tree op1 = NULL_TREE) { aff_tree tmp; - enum tree_code code; - tree cst, core, toffset; poly_int64 bitpos, bitsize, bytepos; - machine_mode mode; - int unsignedp, reversep, volatilep; - - STRIP_NOPS (expr); - code = TREE_CODE (expr); switch (code) { case POINTER_PLUS_EXPR: - tree_to_aff_combination (TREE_OPERAND (expr, 0), type, comb); - tree_to_aff_combination (TREE_OPERAND (expr, 1), sizetype, &tmp); + tree_to_aff_combination (op0, type, comb); + tree_to_aff_combination (op1, sizetype, &tmp); aff_combination_add (comb, &tmp); - return; + return true; case PLUS_EXPR: case MINUS_EXPR: - tree_to_aff_combination (TREE_OPERAND (expr, 0), type, comb); - tree_to_aff_combination (TREE_OPERAND (expr, 1), type, &tmp); + tree_to_aff_combination (op0, type, comb); + tree_to_aff_combination (op1, type, &tmp); if (code == MINUS_EXPR) aff_combination_scale (&tmp, -1); aff_combination_add (comb, &tmp); - return; + return true; case MULT_EXPR: - cst = TREE_OPERAND (expr, 1); - if (TREE_CODE (cst) != INTEGER_CST) + if (TREE_CODE (op1) != INTEGER_CST) break; - tree_to_aff_combination (TREE_OPERAND (expr, 0), type, comb); - aff_combination_scale (comb, wi::to_widest (cst)); - return; + tree_to_aff_combination (op0, type, comb); + aff_combination_scale (comb, wi::to_widest (op1)); + return true; case NEGATE_EXPR: - tree_to_aff_combination (TREE_OPERAND (expr, 0), type, comb); + tree_to_aff_combination (op0, type, comb); aff_combination_scale (comb, -1); - return; + return true; case BIT_NOT_EXPR: /* ~x = -x - 1 */ - tree_to_aff_combination (TREE_OPERAND (expr, 0), type, comb); + tree_to_aff_combination (op0, type, comb); aff_combination_scale (comb, -1); aff_combination_add_cst (comb, -1); - return; - - case ADDR_EXPR: - /* Handle &MEM[ptr + CST] which is equivalent to POINTER_PLUS_EXPR. */ - if (TREE_CODE (TREE_OPERAND (expr, 0)) == MEM_REF) - { - expr = TREE_OPERAND (expr, 0); - tree_to_aff_combination (TREE_OPERAND (expr, 0), type, comb); - tree_to_aff_combination (TREE_OPERAND (expr, 1), sizetype, &tmp); - aff_combination_add (comb, &tmp); - return; - } - core = get_inner_reference (TREE_OPERAND (expr, 0), &bitsize, &bitpos, - &toffset, &mode, &unsignedp, &reversep, - &volatilep); - if (!multiple_p (bitpos, BITS_PER_UNIT, &bytepos)) - break; - aff_combination_const (comb, type, bytepos); - if (TREE_CODE (core) == MEM_REF) - { - tree mem_offset = TREE_OPERAND (core, 1); - aff_combination_add_cst (comb, wi::to_poly_widest (mem_offset)); - core = TREE_OPERAND (core, 0); - } - else - core = build_fold_addr_expr (core); - - if (TREE_CODE (core) == ADDR_EXPR) - aff_combination_add_elt (comb, core, 1); - else - { - tree_to_aff_combination (core, type, &tmp); - aff_combination_add (comb, &tmp); - } - if (toffset) - { - tree_to_aff_combination (toffset, type, &tmp); - aff_combination_add (comb, &tmp); - } - return; + return true; CASE_CONVERT: { - tree otype = TREE_TYPE (expr); - tree inner = TREE_OPERAND (expr, 0); + tree otype = type; + tree inner = op0; tree itype = TREE_TYPE (inner); enum tree_code icode = TREE_CODE (inner); @@ -376,9 +331,7 @@ tree_to_aff_combination (tree expr, tree { op0 = fold_convert (otype, op0); op1 = fold_convert (otype, op1); - expr = fold_build2 (icode, otype, op0, op1); - tree_to_aff_combination (expr, type, comb); - return; + return expr_to_aff_combination (comb, icode, otype, op0, op1); } wide_int minv, maxv; /* If inner type has wrapping overflow behavior, fold conversion @@ -399,15 +352,92 @@ tree_to_aff_combination (tree expr, tree { op0 = fold_convert (otype, op0); op1 = fold_convert (otype, op1); - expr = fold_build2 (MINUS_EXPR, otype, op0, op1); - tree_to_aff_combination (expr, type, comb); - return; + return expr_to_aff_combination (comb, MINUS_EXPR, otype, + op0, op1); } } } } break; + default:; + } + + return false; +} + +/* Splits EXPR into an affine combination of parts. */ + +void +tree_to_aff_combination (tree expr, tree type, aff_tree *comb) +{ + aff_tree tmp; + enum tree_code code; + tree core, toffset; + poly_int64 bitpos, bitsize, bytepos; + machine_mode mode; + int unsignedp, reversep, volatilep; + + STRIP_NOPS (expr); + + code = TREE_CODE (expr); + switch (code) + { + case POINTER_PLUS_EXPR: + case PLUS_EXPR: + case MINUS_EXPR: + case MULT_EXPR: + if (expr_to_aff_combination (comb, code, type, TREE_OPERAND (expr, 0), + TREE_OPERAND (expr, 1))) + return; + break; + + case NEGATE_EXPR: + case BIT_NOT_EXPR: + CASE_CONVERT: + if (expr_to_aff_combination (comb, code, type, TREE_OPERAND (expr, 0))) + return; + break; + + case ADDR_EXPR: + /* Handle &MEM[ptr + CST] which is equivalent to POINTER_PLUS_EXPR. */ + if (TREE_CODE (TREE_OPERAND (expr, 0)) == MEM_REF) + { + expr = TREE_OPERAND (expr, 0); + tree_to_aff_combination (TREE_OPERAND (expr, 0), type, comb); + tree_to_aff_combination (TREE_OPERAND (expr, 1), sizetype, &tmp); + aff_combination_add (comb, &tmp); + return; + } + core = get_inner_reference (TREE_OPERAND (expr, 0), &bitsize, &bitpos, + &toffset, &mode, &unsignedp, &reversep, + &volatilep); + if (!multiple_p (bitpos, BITS_PER_UNIT, &bytepos)) + break; + aff_combination_const (comb, type, bytepos); + if (TREE_CODE (core) == MEM_REF) + { + tree mem_offset = TREE_OPERAND (core, 1); + aff_combination_add_cst (comb, wi::to_poly_widest (mem_offset)); + core = TREE_OPERAND (core, 0); + } + else + core = build_fold_addr_expr (core); + + if (TREE_CODE (core) == ADDR_EXPR) + aff_combination_add_elt (comb, core, 1); + else + { + tree_to_aff_combination (core, type, &tmp); + aff_combination_add (comb, &tmp); + } + if (toffset) + { + tree_to_aff_combination (toffset, type, &tmp); + aff_combination_add (comb, &tmp); + } + return; + default: { if (poly_int_tree_p (expr)) @@ -665,7 +695,7 @@ aff_combination_expand (aff_tree *comb A { unsigned i; aff_tree to_add, current, curre; - tree e, rhs; + tree e; gimple *def; widest_int scale; struct name_expansion *exp; @@ -715,20 +745,27 @@ aff_combination_expand (aff_tree *comb A case PLUS_EXPR: case MINUS_EXPR: case MULT_EXPR: + if (!expr_to_aff_combination (¤t, code, TREE_TYPE (name), + gimple_assign_rhs1 (def), + gimple_assign_rhs2 (def))) + continue; + break; case NEGATE_EXPR: case BIT_NOT_EXPR: CASE_CONVERT: - rhs = gimple_assign_rhs_to_tree (def); + if (!expr_to_aff_combination (¤t, code, TREE_TYPE (name), + gimple_assign_rhs1 (def))) + continue; break; case ADDR_EXPR: case INTEGER_CST: case POLY_INT_CST: - rhs = gimple_assign_rhs1 (def); + tree_to_aff_combination (gimple_assign_rhs1 (def), + TREE_TYPE (name), ¤t); break; default: continue; } - tree_to_aff_combination (rhs, TREE_TYPE (name), ¤t); exp = XNEW (struct name_expansion); exp->in_progress = 1; if (!*cache)