From patchwork Sun Oct 28 15:14:46 2012 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Marc Glisse X-Patchwork-Id: 194710 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]) by ozlabs.org (Postfix) with SMTP id 952052C008C for ; Mon, 29 Oct 2012 02:15:13 +1100 (EST) Comment: DKIM? See http://www.dkim.org DKIM-Signature: v=1; a=rsa-sha1; c=relaxed/relaxed; d=gcc.gnu.org; s=default; x=1352042114; h=Comment: DomainKey-Signature:Received:Received:Received:Received:Received: Date:From:To:Subject:Message-ID:User-Agent:MIME-Version: Content-Type:Mailing-List:Precedence:List-Id:List-Unsubscribe: List-Archive:List-Post:List-Help:Sender:Delivered-To; bh=u8TB4fe Hxvz/dIYDqJ4vr4RvXoA=; b=HtumVJ5Z3Tx6VjgcTWsvX/DtowJLNoZvmNp/gMY pf9Us4J+Luehiw8cxvysW5oxWDHQjSHUlqvz1eguk27YtTDsIZ3jvLmXeJGkwFwQ SDENiOxwCS5EoMRP0nwLAxfn/jkJtAH2LS7Hl2IpQ8b/qHnEx3TzCTWvLXtu9gII 4SdM= Comment: DomainKeys? See http://antispam.yahoo.com/domainkeys DomainKey-Signature: a=rsa-sha1; q=dns; c=nofws; s=default; d=gcc.gnu.org; h=Received:Received:X-SWARE-Spam-Status:X-Spam-Check-By:Received:Received:Received:Date:From:To:Subject:Message-ID:User-Agent:MIME-Version:Content-Type:Mailing-List:Precedence:List-Id:List-Unsubscribe:List-Archive:List-Post:List-Help:Sender:Delivered-To; b=HFLGc2t2FaDCE+5SBL8X5XYKgOoo5Te71CAhHdKC6q/hRPk4xOMDiE4zLcb6Zs BxaW0Kfr2VibFIEIA+AtjhAp9qf7wndQpSxSatu87HGwOlQbUQL/YgGiO9+QjTT9 cLDydCyBA8WSRvCbkYtkbcxG/3htCXp7/xnQnXUmVbHE8=; Received: (qmail 14953 invoked by alias); 28 Oct 2012 15:14:59 -0000 Received: (qmail 14911 invoked by uid 22791); 28 Oct 2012 15:14:56 -0000 X-SWARE-Spam-Status: No, hits=-7.6 required=5.0 tests=AWL, BAYES_00, KHOP_RCVD_UNTRUST, RCVD_IN_DNSWL_HI, RCVD_IN_HOSTKARMA_W, RP_MATCHES_RCVD X-Spam-Check-By: sourceware.org Received: from mail4-relais-sop.national.inria.fr (HELO mail4-relais-sop.national.inria.fr) (192.134.164.105) by sourceware.org (qpsmtpd/0.43rc1) with ESMTP; Sun, 28 Oct 2012 15:14:48 +0000 Received: from stedding.saclay.inria.fr ([193.55.250.194]) by mail4-relais-sop.national.inria.fr with ESMTP/TLS/DHE-RSA-AES128-SHA; 28 Oct 2012 16:14:46 +0100 Received: from glisse (helo=localhost) by stedding.saclay.inria.fr with local-esmtp (Exim 4.80) (envelope-from ) id 1TSUZa-0001Eq-FX for gcc-patches@gcc.gnu.org; Sun, 28 Oct 2012 16:14:46 +0100 Date: Sun, 28 Oct 2012 16:14:46 +0100 (CET) From: Marc Glisse To: gcc-patches@gcc.gnu.org Subject: real_zerop for vectors Message-ID: User-Agent: Alpine 2.02 (DEB 1266 2009-07-14) MIME-Version: 1.0 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 Hello, this patch lets some predicates on floating point constants answer true for vectors, so optimizations are applied. Tested bootstrap + testsuite (default languages). 2012-10-29 Marc Glisse PR middle-end/55027 gcc/ * tree.c (real_zerop, real_onep, real_twop, real_minus_onep): Handle VECTOR_CST. testsuite/ * gcc.dg/pr55027.c: New testcase. Index: gcc/testsuite/gcc.dg/pr55027.c =================================================================== --- gcc/testsuite/gcc.dg/pr55027.c (revision 0) +++ gcc/testsuite/gcc.dg/pr55027.c (revision 0) @@ -0,0 +1,12 @@ +/* { dg-do compile } */ +/* { dg-options "-Ofast -fdump-tree-optimized-raw" } */ + +typedef double v2df __attribute__ ((__vector_size__ (2 * sizeof (double)))); + +void f (v2df *x) +{ + *x = 0 + 1 * *x; +} + +/* { dg-final { scan-tree-dump-not "gimple_assign" "optimized" } } */ +/* { dg-final { cleanup-tree-dump "optimized" } } */ Property changes on: gcc/testsuite/gcc.dg/pr55027.c ___________________________________________________________________ Added: svn:keywords + Author Date Id Revision URL Added: svn:eol-style + native Index: gcc/tree.c =================================================================== --- gcc/tree.c (revision 192894) +++ gcc/tree.c (working copy) @@ -1985,75 +1985,127 @@ tree_floor_log2 (const_tree expr) } /* Return 1 if EXPR is the real constant zero. Trailing zeroes matter for decimal float constants, so don't return 1 for them. */ int real_zerop (const_tree expr) { STRIP_NOPS (expr); - return ((TREE_CODE (expr) == REAL_CST - && REAL_VALUES_EQUAL (TREE_REAL_CST (expr), dconst0) - && !(DECIMAL_FLOAT_MODE_P (TYPE_MODE (TREE_TYPE (expr))))) - || (TREE_CODE (expr) == COMPLEX_CST - && real_zerop (TREE_REALPART (expr)) - && real_zerop (TREE_IMAGPART (expr)))); + switch (TREE_CODE (expr)) + { + case REAL_CST: + return REAL_VALUES_EQUAL (TREE_REAL_CST (expr), dconst0) + && !(DECIMAL_FLOAT_MODE_P (TYPE_MODE (TREE_TYPE (expr)))); + case COMPLEX_CST: + return real_zerop (TREE_REALPART (expr)) + && real_zerop (TREE_IMAGPART (expr)); + case VECTOR_CST: + { + unsigned i; + for (i = 0; i < VECTOR_CST_NELTS (expr); ++i) + if (!real_zerop (VECTOR_CST_ELT (expr, i))) + return false; + return true; + } + default: + return false; + } } /* Return 1 if EXPR is the real constant one in real or complex form. Trailing zeroes matter for decimal float constants, so don't return 1 for them. */ int real_onep (const_tree expr) { STRIP_NOPS (expr); - return ((TREE_CODE (expr) == REAL_CST - && REAL_VALUES_EQUAL (TREE_REAL_CST (expr), dconst1) - && !(DECIMAL_FLOAT_MODE_P (TYPE_MODE (TREE_TYPE (expr))))) - || (TREE_CODE (expr) == COMPLEX_CST - && real_onep (TREE_REALPART (expr)) - && real_zerop (TREE_IMAGPART (expr)))); + switch (TREE_CODE (expr)) + { + case REAL_CST: + return REAL_VALUES_EQUAL (TREE_REAL_CST (expr), dconst1) + && !(DECIMAL_FLOAT_MODE_P (TYPE_MODE (TREE_TYPE (expr)))); + case COMPLEX_CST: + return real_onep (TREE_REALPART (expr)) + && real_zerop (TREE_IMAGPART (expr)); + case VECTOR_CST: + { + unsigned i; + for (i = 0; i < VECTOR_CST_NELTS (expr); ++i) + if (!real_onep (VECTOR_CST_ELT (expr, i))) + return false; + return true; + } + default: + return false; + } } /* Return 1 if EXPR is the real constant two. Trailing zeroes matter for decimal float constants, so don't return 1 for them. */ int real_twop (const_tree expr) { STRIP_NOPS (expr); - return ((TREE_CODE (expr) == REAL_CST - && REAL_VALUES_EQUAL (TREE_REAL_CST (expr), dconst2) - && !(DECIMAL_FLOAT_MODE_P (TYPE_MODE (TREE_TYPE (expr))))) - || (TREE_CODE (expr) == COMPLEX_CST - && real_twop (TREE_REALPART (expr)) - && real_zerop (TREE_IMAGPART (expr)))); + switch (TREE_CODE (expr)) + { + case REAL_CST: + return REAL_VALUES_EQUAL (TREE_REAL_CST (expr), dconst2) + && !(DECIMAL_FLOAT_MODE_P (TYPE_MODE (TREE_TYPE (expr)))); + case COMPLEX_CST: + return real_twop (TREE_REALPART (expr)) + && real_zerop (TREE_IMAGPART (expr)); + case VECTOR_CST: + { + unsigned i; + for (i = 0; i < VECTOR_CST_NELTS (expr); ++i) + if (!real_twop (VECTOR_CST_ELT (expr, i))) + return false; + return true; + } + default: + return false; + } } /* Return 1 if EXPR is the real constant minus one. Trailing zeroes matter for decimal float constants, so don't return 1 for them. */ int real_minus_onep (const_tree expr) { STRIP_NOPS (expr); - return ((TREE_CODE (expr) == REAL_CST - && REAL_VALUES_EQUAL (TREE_REAL_CST (expr), dconstm1) - && !(DECIMAL_FLOAT_MODE_P (TYPE_MODE (TREE_TYPE (expr))))) - || (TREE_CODE (expr) == COMPLEX_CST - && real_minus_onep (TREE_REALPART (expr)) - && real_zerop (TREE_IMAGPART (expr)))); + switch (TREE_CODE (expr)) + { + case REAL_CST: + return REAL_VALUES_EQUAL (TREE_REAL_CST (expr), dconstm1) + && !(DECIMAL_FLOAT_MODE_P (TYPE_MODE (TREE_TYPE (expr)))); + case COMPLEX_CST: + return real_minus_onep (TREE_REALPART (expr)) + && real_zerop (TREE_IMAGPART (expr)); + case VECTOR_CST: + { + unsigned i; + for (i = 0; i < VECTOR_CST_NELTS (expr); ++i) + if (!real_minus_onep (VECTOR_CST_ELT (expr, i))) + return false; + return true; + } + default: + return false; + } } /* Nonzero if EXP is a constant or a cast of a constant. */ int really_constant_p (const_tree exp) { /* This is not quite the same as STRIP_NOPS. It does more. */ while (CONVERT_EXPR_P (exp) || TREE_CODE (exp) == NON_LVALUE_EXPR)