From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (qmail 31617 invoked by alias); 4 May 2015 11:15:43 -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 31605 invoked by uid 89); 4 May 2015 11:15:43 -0000 Authentication-Results: sourceware.org; auth=none X-Virus-Found: No X-Spam-SWARE-Status: No, score=-2.2 required=5.0 tests=AWL,BAYES_00,KAM_ASCII_DIVIDERS,KAM_LAZY_DOMAIN_SECURITY,T_RP_MATCHES_RCVD autolearn=no version=3.3.2 X-HELO: mx2.suse.de Received: from cantor2.suse.de (HELO mx2.suse.de) (195.135.220.15) by sourceware.org (qpsmtpd/0.93/v0.84-503-g423c35a) with (CAMELLIA256-SHA encrypted) ESMTPS; Mon, 04 May 2015 11:15:42 +0000 Received: from relay1.suse.de (charybdis-ext.suse.de [195.135.220.254]) by mx2.suse.de (Postfix) with ESMTP id 06F64ACE9 for ; Mon, 4 May 2015 11:15:39 +0000 (UTC) Date: Mon, 04 May 2015 11:15:00 -0000 From: Richard Biener To: gcc-patches@gcc.gnu.org Subject: [PATCH] Fix PR65935 Message-ID: User-Agent: Alpine 2.11 (LSU 23 2013-08-11) MIME-Version: 1.0 Content-Type: TEXT/PLAIN; charset=US-ASCII X-SW-Source: 2015-05/txt/msg00208.txt.bz2 The following fixes PR65935 where the vectorizer is confused after SLP operands swapping to see the stmts in the IL with unswapped operands. As we already swap for different def-kinds just swap for other swaps as well. Bootstrap and regtest running on x86_64-unknown-linux-gnu. Richard. 2015-05-04 Richard Biener PR tree-optimization/65935 * tree-vect-slp.c (vect_build_slp_tree): If we swapped operands then make sure to apply that swapping to the IL. * gcc.dg/vect/pr65935.c: New testcase. Index: gcc/tree-vect-slp.c =================================================================== *** gcc/tree-vect-slp.c (revision 222758) --- gcc/tree-vect-slp.c (working copy) *************** vect_build_slp_tree (loop_vec_info loop_ *** 1081,1093 **** dump_printf (MSG_NOTE, "%d ", j); } dump_printf (MSG_NOTE, "\n"); ! /* And try again ... */ if (vect_build_slp_tree (loop_vinfo, bb_vinfo, &child, group_size, max_nunits, loads, vectorization_factor, ! matches, npermutes, &this_tree_size, max_tree_size)) { oprnd_info->def_stmts = vNULL; SLP_TREE_CHILDREN (*node).quick_push (child); continue; --- 1081,1105 ---- dump_printf (MSG_NOTE, "%d ", j); } dump_printf (MSG_NOTE, "\n"); ! /* And try again with scratch 'matches' ... */ ! bool *tem = XALLOCAVEC (bool, group_size); if (vect_build_slp_tree (loop_vinfo, bb_vinfo, &child, group_size, max_nunits, loads, vectorization_factor, ! tem, npermutes, &this_tree_size, max_tree_size)) { + /* ... so if successful we can apply the operand swapping + to the GIMPLE IL. This is necessary because for example + vect_get_slp_defs uses operand indexes and thus expects + canonical operand order. */ + for (j = 0; j < group_size; ++j) + if (!matches[j]) + { + gimple stmt = SLP_TREE_SCALAR_STMTS (*node)[j]; + swap_ssa_operands (stmt, gimple_assign_rhs1_ptr (stmt), + gimple_assign_rhs2_ptr (stmt)); + } oprnd_info->def_stmts = vNULL; SLP_TREE_CHILDREN (*node).quick_push (child); continue; Index: gcc/testsuite/gcc.dg/vect/pr65935.c =================================================================== *** gcc/testsuite/gcc.dg/vect/pr65935.c (revision 0) --- gcc/testsuite/gcc.dg/vect/pr65935.c (working copy) *************** *** 0 **** --- 1,63 ---- + /* { dg-do run } */ + /* { dg-additional-options "-O3" } */ + /* { dg-require-effective-target vect_double } */ + + #include "tree-vect.h" + + extern void abort (void); + extern void *malloc (__SIZE_TYPE__); + + struct site { + struct { + struct { + double real; + double imag; + } e[3][3]; + } link[32]; + double phase[32]; + } *lattice; + int sites_on_node; + + void rephase (void) + { + int i,j,k,dir; + struct site *s; + for(i=0,s=lattice;ilink[dir].e[j][k].real *= s->phase[dir]; + s->link[dir].e[j][k].imag *= s->phase[dir]; + } + } + + int main() + { + int i,j,k; + check_vect (); + sites_on_node = 1; + lattice = malloc (sizeof (struct site) * sites_on_node); + for (i = 0; i < 32; ++i) + { + lattice->phase[i] = i; + for (j = 0; j < 3; ++j) + for (k = 0; k < 3; ++k) + { + lattice->link[i].e[j][k].real = 1.0; + lattice->link[i].e[j][k].imag = 1.0; + __asm__ volatile ("" : : : "memory"); + } + } + rephase (); + for (i = 0; i < 32; ++i) + for (j = 0; j < 3; ++j) + for (k = 0; k < 3; ++k) + if (lattice->link[i].e[j][k].real != i + || lattice->link[i].e[j][k].imag != i) + abort (); + return 0; + } + + /* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "slp1" } } */ + /* { dg-final { cleanup-tree-dump "slp1" } } */ + /* { dg-final { cleanup-tree-dump "vect" } } */