From patchwork Tue Oct 6 23:12:46 2015 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Kugan Vivekanandarajah X-Patchwork-Id: 54567 Return-Path: X-Original-To: linaro@patches.linaro.org Delivered-To: linaro@patches.linaro.org Received: from mail-la0-f70.google.com (mail-la0-f70.google.com [209.85.215.70]) by patches.linaro.org (Postfix) with ESMTPS id C99FD22F05 for ; Tue, 6 Oct 2015 23:13:14 +0000 (UTC) Received: by lacwq3 with SMTP id wq3sf170522lac.3 for ; Tue, 06 Oct 2015 16:13:13 -0700 (PDT) X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20130820; h=x-gm-message-state:delivered-to:mailing-list:precedence:list-id :list-unsubscribe:list-archive:list-post:list-help:sender :delivered-to:subject:to:references:cc:from:message-id:date :user-agent:mime-version:in-reply-to:content-type:x-original-sender :x-original-authentication-results; bh=fupkyr/MoIWwFGqhuFMCK2dlUGJntJ+FAkSBaqEYvsQ=; b=C4+BD4WKm/bKl/C6K433ZUhPwrWZ0zx8rFjumfTrs8CXXy97Fgui2/SCFDhTI6omjv lBZK2fKKAQqgYrYgNZLqOMVd9y2oE7CSKQsXasRnXBwqIDkEuk4YpbZ0T8MOrmlR4Rdo knu+mwPBxEZ1bw2p0z50HBHN3/fUXZG/0z5oa2xMzooDuq27CYzmFMhzQllkTZZTpM8q Wn+O5Ggqm+WgAdlQ3qF2PeipqrjZWKPo5PPd/7bprASPU33j9X/GejQxz/7MPzOweNGQ lsFIAfhEWbm4o5VLpYpJ3WNUcDrBnYKcgnEzeKHOqmG/x/BJnOcyvkE2o38ZgI4tdWRh AALQ== X-Gm-Message-State: ALoCoQmBwCkqrsvihdAYvEYbZAqVx87d9GeM/lo/DL5LkXV/41uugS7xMNdAqidf3fp/1WkMBtof X-Received: by 10.180.210.212 with SMTP id mw20mr4134214wic.3.1444173193527; Tue, 06 Oct 2015 16:13:13 -0700 (PDT) X-BeenThere: patchwork-forward@linaro.org Received: by 10.25.31.207 with SMTP id f198ls575lff.31.gmail; Tue, 06 Oct 2015 16:13:13 -0700 (PDT) X-Received: by 10.112.150.67 with SMTP id ug3mr16152053lbb.13.1444173193225; Tue, 06 Oct 2015 16:13:13 -0700 (PDT) Received: from mail-lb0-x22a.google.com (mail-lb0-x22a.google.com. [2a00:1450:4010:c04::22a]) by mx.google.com with ESMTPS id xf5si22797819lbb.93.2015.10.06.16.13.13 for (version=TLSv1.2 cipher=ECDHE-RSA-AES128-GCM-SHA256 bits=128/128); Tue, 06 Oct 2015 16:13:13 -0700 (PDT) Received-SPF: pass (google.com: domain of patch+caf_=patchwork-forward=linaro.org@linaro.org designates 2a00:1450:4010:c04::22a as permitted sender) client-ip=2a00:1450:4010:c04::22a; Received: by lbbwt4 with SMTP id wt4so280972lbb.1 for ; Tue, 06 Oct 2015 16:13:13 -0700 (PDT) X-Received: by 10.25.211.201 with SMTP id k192mr10651345lfg.32.1444173193055; Tue, 06 Oct 2015 16:13:13 -0700 (PDT) X-Forwarded-To: patchwork-forward@linaro.org X-Forwarded-For: patch@linaro.org patchwork-forward@linaro.org Delivered-To: patch@linaro.org Received: by 10.112.59.35 with SMTP id w3csp2115535lbq; Tue, 6 Oct 2015 16:13:11 -0700 (PDT) X-Received: by 10.50.171.161 with SMTP id av1mr19087582igc.6.1444173191570; Tue, 06 Oct 2015 16:13:11 -0700 (PDT) Received: from sourceware.org (server1.sourceware.org. [209.132.180.131]) by mx.google.com with ESMTPS id cj8si10196351igb.49.2015.10.06.16.13.11 for (version=TLS1_2 cipher=ECDHE-RSA-AES128-GCM-SHA256 bits=128/128); Tue, 06 Oct 2015 16:13:11 -0700 (PDT) Received-SPF: pass (google.com: domain of gcc-patches-return-409429-patch=linaro.org@gcc.gnu.org designates 209.132.180.131 as permitted sender) client-ip=209.132.180.131; Received: (qmail 50987 invoked by alias); 6 Oct 2015 23:12:57 -0000 Mailing-List: list patchwork-forward@linaro.org; contact patchwork-forward+owners@linaro.org Precedence: list 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 50277 invoked by uid 89); 6 Oct 2015 23:12:56 -0000 X-Virus-Found: No X-Spam-SWARE-Status: No, score=-2.4 required=5.0 tests=AWL, BAYES_00, RCVD_IN_DNSWL_LOW, SPF_PASS autolearn=ham version=3.3.2 X-HELO: mail-pa0-f42.google.com Received: from mail-pa0-f42.google.com (HELO mail-pa0-f42.google.com) (209.85.220.42) by sourceware.org (qpsmtpd/0.93/v0.84-503-g423c35a) with (AES128-GCM-SHA256 encrypted) ESMTPS; Tue, 06 Oct 2015 23:12:54 +0000 Received: by pacfv12 with SMTP id fv12so606835pac.2 for ; Tue, 06 Oct 2015 16:12:52 -0700 (PDT) X-Received: by 10.66.252.35 with SMTP id zp3mr49486169pac.43.1444173172752; Tue, 06 Oct 2015 16:12:52 -0700 (PDT) Received: from [10.1.1.10] (58-6-183-210.dyn.iinet.net.au. [58.6.183.210]) by smtp.googlemail.com with ESMTPSA id uc1sm35692818pab.20.2015.10.06.16.12.50 (version=TLSv1.2 cipher=ECDHE-RSA-AES128-GCM-SHA256 bits=128/128); Tue, 06 Oct 2015 16:12:51 -0700 (PDT) Subject: Re: [3/7] Optimize ZEXT_EXPR with tree-vrp To: Richard Biener References: <55ECFC2A.7050908@linaro.org> <55ECFD57.5060507@linaro.org> Cc: "gcc-patches@gcc.gnu.org" From: kugan Message-ID: <5614556E.5020908@linaro.org> Date: Wed, 7 Oct 2015 10:12:46 +1100 User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:38.0) Gecko/20100101 Thunderbird/38.2.0 MIME-Version: 1.0 In-Reply-To: X-IsSubscribed: yes X-Original-Sender: kugan.vivekanandarajah@linaro.org X-Original-Authentication-Results: mx.google.com; spf=pass (google.com: domain of patch+caf_=patchwork-forward=linaro.org@linaro.org designates 2a00:1450:4010:c04::22a as permitted sender) smtp.mailfrom=patch+caf_=patchwork-forward=linaro.org@linaro.org; dkim=pass header.i=@gcc.gnu.org X-Google-Group-Id: 836684582541 Hi Richard, Thanks for the review. On 15/09/15 23:08, Richard Biener wrote: > On Mon, Sep 7, 2015 at 4:58 AM, Kugan wrote: >> This patch tree-vrp handling and optimization for ZEXT_EXPR. > > + else if (code == SEXT_EXPR) > + { > + gcc_assert (range_int_cst_p (&vr1)); > + unsigned int prec = tree_to_uhwi (vr1.min); > + type = vr0.type; > + wide_int tmin, tmax; > + wide_int type_min, type_max; > + wide_int may_be_nonzero, must_be_nonzero; > + > + gcc_assert (!TYPE_UNSIGNED (expr_type)); > > hmm, I don't think we should restrict SEXT_EXPR this way. SEXT_EXPR > should operate on both signed and unsigned types and the result type > should be the same as the type of operand 0. > > + type_min = wi::shwi (1 << (prec - 1), > + TYPE_PRECISION (TREE_TYPE (vr0.min))); > + type_max = wi::shwi (((1 << (prec - 1)) - 1), > + TYPE_PRECISION (TREE_TYPE (vr0.max))); > > there is wi::min_value and max_value for this. As of now, SEXT_EXPR in gimple is of the form: x = y sext 8 and types of all the operand and results are of the wider type. Therefore we cant use the wi::min_value. Or do you want to convert this precision (in this case 8) to a type and use wi::min_value? Please find the patch that addresses the other comments. Thanks, Kugan > > + HOST_WIDE_INT int_may_be_nonzero = may_be_nonzero.to_uhwi (); > + HOST_WIDE_INT int_must_be_nonzero = must_be_nonzero.to_uhwi (); > > this doesn't need to fit a HOST_WIDE_INT, please use wi::bit_and (can't > find a test_bit with a quick search). > > + tmin = wi::sext (tmin, prec - 1); > + tmax = wi::sext (tmax, prec - 1); > + min = wide_int_to_tree (expr_type, tmin); > + max = wide_int_to_tree (expr_type, tmax); > > not sure why you need the extra sign-extensions here. > > + case SEXT_EXPR: > + { > + gcc_assert (is_gimple_min_invariant (op1)); > + unsigned int prec = tree_to_uhwi (op1); > > no need to assert, tree_to_uhwi will do that for you. > > + HOST_WIDE_INT may_be_nonzero = may_be_nonzero0.to_uhwi (); > + HOST_WIDE_INT must_be_nonzero = must_be_nonzero0.to_uhwi (); > > likewise with HOST_WIDE__INT issue. > > Otherwise looks ok to me. Btw, this and adding of SEXT_EXPR could be > accompanied with a match.pd pattern detecting sign-extension patterns, > that would give some extra test coverage. > > Thanks, > Richard. > >> >> >> gcc/ChangeLog: >> >> 2015-09-07 Kugan Vivekanandarajah >> >> * tree-vrp.c (extract_range_from_binary_expr_1): Handle SEXT_EXPR. >> (simplify_bit_ops_using_ranges): Likewise. >> (simplify_stmt_using_ranges): Likewise. >From 75fb9b8bcacd36a1409bf94c38048de83a5eab62 Mon Sep 17 00:00:00 2001 From: Kugan Vivekanandarajah Date: Mon, 17 Aug 2015 13:45:52 +1000 Subject: [PATCH 3/7] Optimize ZEXT_EXPR with tree-vrp --- gcc/tree-vrp.c | 73 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 73 insertions(+) diff --git a/gcc/tree-vrp.c b/gcc/tree-vrp.c index 2cd71a2..9c7d8d8 100644 --- a/gcc/tree-vrp.c +++ b/gcc/tree-vrp.c @@ -2317,6 +2317,7 @@ extract_range_from_binary_expr_1 (value_range_t *vr, && code != LSHIFT_EXPR && code != MIN_EXPR && code != MAX_EXPR + && code != SEXT_EXPR && code != BIT_AND_EXPR && code != BIT_IOR_EXPR && code != BIT_XOR_EXPR) @@ -2877,6 +2878,53 @@ extract_range_from_binary_expr_1 (value_range_t *vr, extract_range_from_multiplicative_op_1 (vr, code, &vr0, &vr1); return; } + else if (code == SEXT_EXPR) + { + gcc_assert (range_int_cst_p (&vr1)); + unsigned int prec = tree_to_uhwi (vr1.min); + type = vr0.type; + wide_int tmin, tmax; + wide_int sign_bit; + wide_int type_min, type_max; + wide_int may_be_nonzero, must_be_nonzero; + + type_min = wi::shwi (1 << (prec - 1), + TYPE_PRECISION (TREE_TYPE (vr0.min))); + type_max = wi::shwi (((1 << (prec - 1)) - 1), + TYPE_PRECISION (TREE_TYPE (vr0.max))); + sign_bit = wi::shwi (1 << (prec - 1), + TYPE_PRECISION (TREE_TYPE (vr0.min))); + if (zero_nonzero_bits_from_vr (expr_type, &vr0, + &may_be_nonzero, + &must_be_nonzero)) + { + if (wi::bit_and (must_be_nonzero, sign_bit) == sign_bit) + { + /* If to-be-extended sign bit is one. */ + tmin = type_min; + tmax = may_be_nonzero; + } + else if (wi::bit_and (may_be_nonzero, sign_bit) + != sign_bit) + { + /* If to-be-extended sign bit is zero. */ + tmin = must_be_nonzero; + tmax = may_be_nonzero; + } + else + { + tmin = type_min; + tmax = type_max; + } + } + else + { + tmin = type_min; + tmax = type_max; + } + min = wide_int_to_tree (expr_type, tmin); + max = wide_int_to_tree (expr_type, tmax); + } else if (code == RSHIFT_EXPR || code == LSHIFT_EXPR) { @@ -9244,6 +9292,30 @@ simplify_bit_ops_using_ranges (gimple_stmt_iterator *gsi, gimple *stmt) break; } break; + case SEXT_EXPR: + { + gcc_assert (is_gimple_min_invariant (op1)); + unsigned int prec = tree_to_uhwi (op1); + wide_int mask, sign_bit; + mask = wi::shwi (((1 << (prec - 1)) - 1), + TYPE_PRECISION (TREE_TYPE (vr0.max))); + mask = wi::bit_not (mask); + sign_bit = wi::shwi (1 << (prec - 1), + TYPE_PRECISION (TREE_TYPE (vr0.min))); + if (wi::bit_and (must_be_nonzero0, sign_bit) == sign_bit) + { + /* If to-be-extended sign bit is one. */ + if (wi::bit_and (must_be_nonzero0, mask) == mask) + op = op0; + } + else if (wi::bit_and (may_be_nonzero0, sign_bit) != sign_bit) + { + /* If to-be-extended sign bit is zero. */ + if (wi::bit_and (may_be_nonzero0, mask) == 0) + op = op0; + } + } + break; default: gcc_unreachable (); } @@ -9946,6 +10018,7 @@ simplify_stmt_using_ranges (gimple_stmt_iterator *gsi) case BIT_AND_EXPR: case BIT_IOR_EXPR: + case SEXT_EXPR: /* Optimize away BIT_AND_EXPR and BIT_IOR_EXPR if all the bits being cleared are already cleared or all the bits being set are already set. */ -- 1.9.1