From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: 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-Archive: List-Post: List-Help: Sender: gcc-patches-owner@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 10:30:00 -0000 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 Content-Type: text/plain; charset=US-ASCII X-SW-Source: 2018-12/txt/msg00655.txt.bz2 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)