From patchwork Mon Jan 24 13:01:04 2022 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: liuhongt X-Patchwork-Id: 1583447 Return-Path: X-Original-To: incoming@patchwork.ozlabs.org Delivered-To: patchwork-incoming@bilbo.ozlabs.org Authentication-Results: bilbo.ozlabs.org; dkim=pass (1024-bit key; unprotected) header.d=gcc.gnu.org header.i=@gcc.gnu.org header.a=rsa-sha256 header.s=default header.b=tYly3xZE; dkim-atps=neutral Authentication-Results: ozlabs.org; spf=pass (sender SPF authorized) smtp.mailfrom=gcc.gnu.org (client-ip=2620:52:3:1:0:246e:9693:128c; helo=sourceware.org; envelope-from=gcc-patches-bounces+incoming=patchwork.ozlabs.org@gcc.gnu.org; receiver=) Received: from sourceware.org (server2.sourceware.org [IPv6:2620:52:3:1:0:246e:9693:128c]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature RSA-PSS (4096 bits) server-digest SHA256) (No client certificate requested) by bilbo.ozlabs.org (Postfix) with ESMTPS id 4Jj9986F16z9tT8 for ; Tue, 25 Jan 2022 00:01:31 +1100 (AEDT) Received: from server2.sourceware.org (localhost [IPv6:::1]) by sourceware.org (Postfix) with ESMTP id 790113858D39 for ; Mon, 24 Jan 2022 13:01:28 +0000 (GMT) DKIM-Filter: OpenDKIM Filter v2.11.0 sourceware.org 790113858D39 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gcc.gnu.org; s=default; t=1643029288; bh=6nQJO10tbdtB2N54FnvdFg7tatluQHLAceIaV/CuZXU=; h=To:Subject:Date:List-Id:List-Unsubscribe:List-Archive:List-Post: List-Help:List-Subscribe:From:Reply-To:From; b=tYly3xZE50Mp+gaJLqipRlQp8weQOjWsU5mdqYda5LHUx22jCW6fz0d2rZD44jp87 80KaouL9bsva7Nis3C6T8zeLIvh1mgrRzU9pibw5+ZAmZJxzVzW5c+IBC26Tqar4YA dL/utG0X5g/p6k/+5naL6X+6MIFsa4801MFcLoDg= X-Original-To: gcc-patches@gcc.gnu.org Delivered-To: gcc-patches@gcc.gnu.org Received: from mga06.intel.com (mga06.intel.com [134.134.136.31]) by sourceware.org (Postfix) with ESMTPS id 91F5E3858D39 for ; Mon, 24 Jan 2022 13:01:07 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.4.1 sourceware.org 91F5E3858D39 X-IronPort-AV: E=McAfee;i="6200,9189,10236"; a="306753054" X-IronPort-AV: E=Sophos;i="5.88,311,1635231600"; d="scan'208";a="306753054" Received: from orsmga007.jf.intel.com ([10.7.209.58]) by orsmga104.jf.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 24 Jan 2022 05:01:06 -0800 X-ExtLoop1: 1 X-IronPort-AV: E=Sophos;i="5.88,311,1635231600"; d="scan'208";a="519936676" Received: from scymds01.sc.intel.com ([10.148.94.138]) by orsmga007.jf.intel.com with ESMTP; 24 Jan 2022 05:01:06 -0800 Received: from shliclel320.sh.intel.com (shliclel320.sh.intel.com [10.239.236.50]) by scymds01.sc.intel.com with ESMTP id 20OD144N021673; Mon, 24 Jan 2022 05:01:05 -0800 To: gcc-patches@gcc.gnu.org Subject: [PATCH] [vect] Add vect_recog_cond_expr_convert_pattern. Date: Mon, 24 Jan 2022 21:01:04 +0800 Message-Id: <20220124130104.10808-1-hongtao.liu@intel.com> X-Mailer: git-send-email 2.18.1 X-Spam-Status: No, score=-12.5 required=5.0 tests=BAYES_00, DKIMWL_WL_HIGH, DKIM_SIGNED, DKIM_VALID, DKIM_VALID_AU, DKIM_VALID_EF, GIT_PATCH_0, KAM_SHORT, RCVD_IN_MSPIKE_H2, SPF_HELO_NONE, SPF_NONE, TXREP autolearn=ham autolearn_force=no version=3.4.4 X-Spam-Checker-Version: SpamAssassin 3.4.4 (2020-01-24) on server2.sourceware.org X-BeenThere: gcc-patches@gcc.gnu.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: Gcc-patches mailing list List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , X-Patchwork-Original-From: liuhongt via Gcc-patches From: liuhongt Reply-To: liuhongt Errors-To: gcc-patches-bounces+incoming=patchwork.ozlabs.org@gcc.gnu.org Sender: "Gcc-patches" The pattern converts (cond (cmp a b) (convert c) (convert d)) to (convert (cond (cmp a b) c d)) when 1) types_match (c, d) 2) single_use for (convert c) and (convert d) 3) TYPE_PRECISION (TREE_TYPE (c)) == TYPE_PRECISION (TREE_TYPE (a)) 4) INTEGERAL_TYPE_P (TREE_TYPE (c)) The pattern can save packing of mask and data(partial for data, 2 vs 1). Bootstrapped and regtested for x86_64-pc-linux-gnu{-m32,} and x86_64-pc-linux-gnu{-m32\ -march=native,\ -march=native} on CLX. Ok for trunk? gcc/ChangeLog: PR target/103771 * match.pd (cond_expr_convert_p): New match. * tree-vect-patterns.cc (gimple_cond_expr_convert_p): Declare. (vect_recog_cond_expr_convert_pattern): New. gcc/testsuite/ChangeLog: * gcc.target/i386/pr103771-2.c: New test. --- gcc/match.pd | 8 +++ gcc/testsuite/gcc.target/i386/pr103771-2.c | 8 +++ gcc/tree-vect-patterns.cc | 83 ++++++++++++++++++++++ 3 files changed, 99 insertions(+) create mode 100644 gcc/testsuite/gcc.target/i386/pr103771-2.c diff --git a/gcc/match.pd b/gcc/match.pd index c68eed70a26..5808c4561ee 100644 --- a/gcc/match.pd +++ b/gcc/match.pd @@ -7647,3 +7647,11 @@ and, to the number of trailing zeroes. */ (match (ctz_table_index @1 @2 @3) (rshift (mult (bit_and:c (negate @1) @1) INTEGER_CST@2) INTEGER_CST@3)) + +(match (cond_expr_convert_p @0 @2 @3 @6) + (cond (simple_comparison@6 @0 @1) (convert@4 @2) (convert@5 @3)) + (if (types_match (TREE_TYPE (@2), TREE_TYPE (@3)) + && INTEGRAL_TYPE_P (type) + && INTEGRAL_TYPE_P (TREE_TYPE (@2)) + && single_use (@4) + && single_use (@5)))) diff --git a/gcc/testsuite/gcc.target/i386/pr103771-2.c b/gcc/testsuite/gcc.target/i386/pr103771-2.c new file mode 100644 index 00000000000..962a3a74ecf --- /dev/null +++ b/gcc/testsuite/gcc.target/i386/pr103771-2.c @@ -0,0 +1,8 @@ +/* { dg-do compile } */ +/* { dg-options "-march=cascadelake -O3" } */ +/* { dg-final { scan-assembler-not "kunpck" } } */ +/* { dg-final { scan-assembler-not "kand" } } */ +/* { dg-final { scan-assembler-not "kor" } } */ +/* { dg-final { scan-assembler-not "kshift" } } */ + +#include "pr103771.c" diff --git a/gcc/tree-vect-patterns.cc b/gcc/tree-vect-patterns.cc index bea04992160..cbdfa96789c 100644 --- a/gcc/tree-vect-patterns.cc +++ b/gcc/tree-vect-patterns.cc @@ -924,6 +924,88 @@ vect_reassociating_reduction_p (vec_info *vinfo, return true; } +/* match.pd function to match + (cond (cmp@3 a b) (convert@1 c) (convert@2 d)) + with conditions: + 1) there's single_use for both @1 and @2. + 2) c and d have same type. + record a and c and d and @3. */ + +extern bool gimple_cond_expr_convert_p (tree, tree*, tree (*)(tree)); + +/* Function vect_recog_cond_expr_convert + + Try to find the following pattern: + + TYPE1 A, B; + TYPE2 C,D; + TYPE3 E; + TYPE3 op_true = (TYPE3)A; + TYPE4 op_false = (TYPE3)B; + + E = C cmp D ? op_true : op_false; + + where + TYPE_PRECISION (TYPE1) != TYPE_PRECISION (TYPE3); + TYPE_PRECISION (TYPE1) == TYPE_PRECISION (TYPE2); + single_use of op_true and op_false. + + Input: + + * STMT_VINFO: The stmt from which the pattern search begins. + here it starts with E = c cmp D ? op_true : op_false; + + Output: + + TYPE1 E' = C cmp D ? A : B; + TYPE3 E = (TYPE3) E'; + + * TYPE_OUT: The vector type of the output of this pattern. + + * Return value: A new stmt that will be used to replace the sequence of + stmts that constitute the pattern. In this case it will be: + E = (TYPE3)E'; + E' = C cmp D ? A : B; is recorded in pattern definition statements; */ + +static gimple * +vect_recog_cond_expr_convert_pattern (vec_info *vinfo, + stmt_vec_info stmt_vinfo, tree *type_out) +{ + gassign *last_stmt = dyn_cast (stmt_vinfo->stmt); + tree lhs, match[4], temp, type, new_lhs; + gimple *cond_stmt; + gimple *pattern_stmt; + + if (!last_stmt) + return NULL; + + lhs = gimple_assign_lhs (last_stmt); + + /* Find E = C cmp D ? (TYPE3) A ? (TYPE3) B; + TYPE_PRECISION (A) == TYPE_PRECISION (C). */ + if (!gimple_cond_expr_convert_p (lhs, &match[0], NULL) + || (TYPE_PRECISION (TREE_TYPE (match[0])) + != TYPE_PRECISION (TREE_TYPE (match[1])))) + return NULL; + + vect_pattern_detected ("vect_recog_cond_expr_convert_pattern", last_stmt); + + type = TREE_TYPE (match[1]); + temp = vect_recog_temp_ssa_var (type, NULL); + cond_stmt = gimple_build_assign (temp, build3 (COND_EXPR, type, match[3], + match[1], match[2])); + append_pattern_def_seq (vinfo, stmt_vinfo, cond_stmt, + get_vectype_for_scalar_type (vinfo, type)); + new_lhs = vect_recog_temp_ssa_var (TREE_TYPE (lhs), NULL); + pattern_stmt = gimple_build_assign (new_lhs, CONVERT_EXPR, temp); + *type_out = STMT_VINFO_VECTYPE (stmt_vinfo); + + if (dump_enabled_p ()) + dump_printf_loc (MSG_NOTE, vect_location, + "created pattern stmt: %G", pattern_stmt); + return pattern_stmt; +} + /* Function vect_recog_dot_prod_pattern Try to find the following pattern: @@ -5492,6 +5574,7 @@ static vect_recog_func vect_vect_recog_func_ptrs[] = { /* Must come after over_widening, which narrows the shift as much as possible beforehand. */ { vect_recog_average_pattern, "average" }, + { vect_recog_cond_expr_convert_pattern, "cond_expr_convert" }, { vect_recog_mulhs_pattern, "mult_high" }, { vect_recog_cast_forwprop_pattern, "cast_forwprop" }, { vect_recog_widen_mult_pattern, "widen_mult" },