From patchwork Wed Jun 26 01:45:59 2024 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: "Li, Pan2" X-Patchwork-Id: 1952321 Return-Path: X-Original-To: incoming@patchwork.ozlabs.org Delivered-To: patchwork-incoming@legolas.ozlabs.org Authentication-Results: legolas.ozlabs.org; dkim=pass (2048-bit key; unprotected) header.d=intel.com header.i=@intel.com header.a=rsa-sha256 header.s=Intel header.b=mD6eFiI3; dkim-atps=neutral Authentication-Results: legolas.ozlabs.org; spf=pass (sender SPF authorized) smtp.mailfrom=gcc.gnu.org (client-ip=8.43.85.97; helo=server2.sourceware.org; envelope-from=gcc-patches-bounces+incoming=patchwork.ozlabs.org@gcc.gnu.org; receiver=patchwork.ozlabs.org) Received: from server2.sourceware.org (server2.sourceware.org [8.43.85.97]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature ECDSA (secp384r1) server-digest SHA384) (No client certificate requested) by legolas.ozlabs.org (Postfix) with ESMTPS id 4W84LT1DJqz20X6 for ; Wed, 26 Jun 2024 11:46:37 +1000 (AEST) Received: from server2.sourceware.org (localhost [IPv6:::1]) by sourceware.org (Postfix) with ESMTP id 0719A3870C24 for ; Wed, 26 Jun 2024 01:46:34 +0000 (GMT) X-Original-To: gcc-patches@gcc.gnu.org Delivered-To: gcc-patches@gcc.gnu.org Received: from mgamail.intel.com (mgamail.intel.com [192.198.163.11]) by sourceware.org (Postfix) with ESMTPS id BA15438708D6 for ; Wed, 26 Jun 2024 01:46:07 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.4.2 sourceware.org BA15438708D6 Authentication-Results: sourceware.org; dmarc=pass (p=none dis=none) header.from=intel.com Authentication-Results: sourceware.org; spf=pass smtp.mailfrom=intel.com ARC-Filter: OpenARC Filter v1.0.0 sourceware.org BA15438708D6 Authentication-Results: server2.sourceware.org; arc=none smtp.remote-ip=192.198.163.11 ARC-Seal: i=1; a=rsa-sha256; d=sourceware.org; s=key; t=1719366372; cv=none; b=JBI5NBAkAwn13A1bgNgrSL4b3xnTOTnS/ivaz8YmjMlk0wzSl0rTI5lNovWv5jyKwL9gAAewXjQmd9DnBSpDXa/seU6u0xl+TD3z2xHOTEWN4wNP4OUCjLFoy14Ry7Zb0RS3bSapDT15uu4LKJeRyDJlKp6nvVgREBQH8V742Y0= ARC-Message-Signature: i=1; a=rsa-sha256; d=sourceware.org; s=key; t=1719366372; c=relaxed/simple; bh=qJijpwVFuizNRWLcx39LMLbDEtlRea1rvcNQHmjq8Fc=; h=DKIM-Signature:From:To:Subject:Date:Message-Id:MIME-Version; b=mQ54J3k8w2VF4pDXH1IJ3wJyIx2WkDTEEqWa+5ZYaBz3Q2YCK3pZXwG19zelq2E8H0aA7TQkjT3/G4bF76vuJbYyouXXzUmH+CI8DV/sdHzKgkKTrY9uLRADsKGSGWnjshh1s+SFq+nxNfu1oOANrtle8MzMHlZu9WOJoXTV+U4= ARC-Authentication-Results: i=1; server2.sourceware.org DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=intel.com; i=@intel.com; q=dns/txt; s=Intel; t=1719366368; x=1750902368; h=from:to:cc:subject:date:message-id:mime-version: content-transfer-encoding; bh=qJijpwVFuizNRWLcx39LMLbDEtlRea1rvcNQHmjq8Fc=; b=mD6eFiI3TpcTQMvARJb9QtKNO/aH77l0aeOq3c17VVj5kbx3gOX7M5Kg SetMiXe03BFDRjgUbIyJE4eeLH3HvutW8W5P//58GYqJdTMV/Iqs9BHvF goQJTomDw6s76uLKOu6kCFXP2qt9X8d64o1Q1gviCDztRKcNyABhj4OFF GMJKpXmLIkNN1u9V/4aMkywifHIvoTuTWoBJ3l7q3IRyy9B4VlNU+hdli S2nk0le3v3M3yWAP+4o+rHglvCMk6Wyv2F+koNIDdSqqNsB66RMrYSAJo /MahzCMMVxgjpWQbER/KWwnxN5s2kh2k5jjXb7mB9DH5eqDADasHcN8gm w==; X-CSE-ConnectionGUID: T4sGaYnlScmRBrN62YcT2w== X-CSE-MsgGUID: m8KVY5/XR6WzC9W4ANQAQg== X-IronPort-AV: E=McAfee;i="6700,10204,11114"; a="27035408" X-IronPort-AV: E=Sophos;i="6.08,265,1712646000"; d="scan'208";a="27035408" Received: from orviesa001.jf.intel.com ([10.64.159.141]) by fmvoesa105.fm.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 25 Jun 2024 18:46:06 -0700 X-CSE-ConnectionGUID: AT9J3GAgTNCP9Wfb01WHAg== X-CSE-MsgGUID: 7lpqIBblQf6WURTwyXM5oA== X-ExtLoop1: 1 X-IronPort-AV: E=Sophos;i="6.08,265,1712646000"; d="scan'208";a="81373022" Received: from shvmail02.sh.intel.com ([10.239.244.9]) by orviesa001.jf.intel.com with ESMTP; 25 Jun 2024 18:46:04 -0700 Received: from pli-ubuntu.sh.intel.com (pli-ubuntu.sh.intel.com [10.239.159.47]) by shvmail02.sh.intel.com (Postfix) with ESMTP id 5A0E010071D7; Wed, 26 Jun 2024 09:46:03 +0800 (CST) From: pan2.li@intel.com To: gcc-patches@gcc.gnu.org Cc: juzhe.zhong@rivai.ai, kito.cheng@gmail.com, richard.guenther@gmail.com, jeffreyalaw@gmail.com, rdapp.gcc@gmail.com, Pan Li Subject: [PATCH v1] Internal-fn: Support new IFN SAT_TRUNC for unsigned scalar int Date: Wed, 26 Jun 2024 09:45:59 +0800 Message-Id: <20240626014559.765149-1-pan2.li@intel.com> X-Mailer: git-send-email 2.34.1 MIME-Version: 1.0 X-Spam-Status: No, score=-11.6 required=5.0 tests=BAYES_00, DKIMWL_WL_HIGH, DKIM_SIGNED, DKIM_VALID, DKIM_VALID_AU, DKIM_VALID_EF, GIT_PATCH_0, RCVD_IN_MSPIKE_H2, SPF_HELO_NONE, SPF_NONE, TXREP autolearn=ham autolearn_force=no version=3.4.6 X-Spam-Checker-Version: SpamAssassin 3.4.6 (2021-04-09) on server2.sourceware.org X-BeenThere: gcc-patches@gcc.gnu.org X-Mailman-Version: 2.1.30 Precedence: list List-Id: Gcc-patches mailing list List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: gcc-patches-bounces+incoming=patchwork.ozlabs.org@gcc.gnu.org From: Pan Li This patch would like to add the middle-end presentation for the saturation truncation. Aka set the result of truncated value to the max value when overflow. It will take the pattern similar as below. Form 1: #define DEF_SAT_U_TRUC_FMT_1(WT, NT) \ NT __attribute__((noinline)) \ sat_u_truc_##T##_fmt_1 (WT x) \ { \ bool overflow = x > (WT)(NT)(-1); \ return ((NT)x) | (NT)-overflow; \ } For example, truncated uint16_t to uint8_t, we have * SAT_TRUNC (254) => 254 * SAT_TRUNC (255) => 255 * SAT_TRUNC (256) => 255 * SAT_TRUNC (65536) => 255 Given below SAT_TRUNC from uint64_t to uint32_t. DEF_SAT_U_TRUC_FMT_1 (uint64_t, uint32_t) Before this patch: __attribute__((noinline)) uint32_t sat_u_truc_T_fmt_1 (uint64_t x) { _Bool overflow; unsigned int _1; unsigned int _2; unsigned int _3; uint32_t _6; ;; basic block 2, loop depth 0 ;; pred: ENTRY overflow_5 = x_4(D) > 4294967295; _1 = (unsigned int) x_4(D); _2 = (unsigned int) overflow_5; _3 = -_2; _6 = _1 | _3; return _6; ;; succ: EXIT } After this patch: __attribute__((noinline)) uint32_t sat_u_truc_T_fmt_1 (uint64_t x) { uint32_t _6; ;; basic block 2, loop depth 0 ;; pred: ENTRY _6 = .SAT_TRUNC (x_4(D)); [tail call] return _6; ;; succ: EXIT } The below tests are passed for this patch: *. The rv64gcv fully regression tests. *. The rv64gcv build with glibc. *. The x86 bootstrap tests. *. The x86 fully regression tests. gcc/ChangeLog: * internal-fn.def (SAT_TRUNC): Add new signed IFN sat_trunc as unary_convert. * match.pd: Add new matching pattern for unsigned int sat_trunc. * optabs.def (OPTAB_CL): Add unsigned and signed optab. * tree-ssa-math-opts.cc (gimple_unsigend_integer_sat_trunc): Add new decl for the matching pattern generated func. (match_unsigned_saturation_trunc): Add new func impl to match the .SAT_TRUNC. (math_opts_dom_walker::after_dom_children): Add .SAT_TRUNC match function under BIT_IOR_EXPR case. * tree.cc (integer_half_truncated_all_ones_p): Add new func impl to filter the truncated threshold. * tree.h (integer_half_truncated_all_ones_p): Add new func decl. Signed-off-by: Pan Li --- gcc/internal-fn.def | 2 ++ gcc/match.pd | 12 +++++++++++- gcc/optabs.def | 3 +++ gcc/tree-ssa-math-opts.cc | 32 ++++++++++++++++++++++++++++++++ gcc/tree.cc | 22 ++++++++++++++++++++++ gcc/tree.h | 6 ++++++ 6 files changed, 76 insertions(+), 1 deletion(-) diff --git a/gcc/internal-fn.def b/gcc/internal-fn.def index a8c83437ada..915d329c05a 100644 --- a/gcc/internal-fn.def +++ b/gcc/internal-fn.def @@ -278,6 +278,8 @@ DEF_INTERNAL_SIGNED_OPTAB_FN (MULHRS, ECF_CONST | ECF_NOTHROW, first, DEF_INTERNAL_SIGNED_OPTAB_FN (SAT_ADD, ECF_CONST, first, ssadd, usadd, binary) DEF_INTERNAL_SIGNED_OPTAB_FN (SAT_SUB, ECF_CONST, first, sssub, ussub, binary) +DEF_INTERNAL_SIGNED_OPTAB_FN (SAT_TRUNC, ECF_CONST, first, sstrunc, ustrunc, unary_convert) + DEF_INTERNAL_COND_FN (ADD, ECF_CONST, add, binary) DEF_INTERNAL_COND_FN (SUB, ECF_CONST, sub, binary) DEF_INTERNAL_COND_FN (MUL, ECF_CONST, smul, binary) diff --git a/gcc/match.pd b/gcc/match.pd index 3d0689c9312..d4062434cc7 100644 --- a/gcc/match.pd +++ b/gcc/match.pd @@ -39,7 +39,8 @@ along with GCC; see the file COPYING3. If not see HONOR_NANS uniform_vector_p expand_vec_cmp_expr_p - bitmask_inv_cst_vector_p) + bitmask_inv_cst_vector_p + integer_half_truncated_all_ones_p) /* Operator lists. */ (define_operator_list tcc_comparison @@ -3210,6 +3211,15 @@ DEFINE_INT_AND_FLOAT_ROUND_FN (RINT) (if (INTEGRAL_TYPE_P (type) && TYPE_UNSIGNED (type) && types_match (type, @0, @1)))) +/* Unsigned saturation truncate, case 1 (), sizeof (WT) > sizeof (NT). + SAT_U_TRUNC = (NT)x | (NT)(-(X > (WT)(NT)(-1))). */ +(match (unsigend_integer_sat_trunc @0) + (bit_ior:c (negate (convert (gt @0 integer_half_truncated_all_ones_p))) + (convert @0)) + (if (INTEGRAL_TYPE_P (type) && TYPE_UNSIGNED (type) + && TYPE_UNSIGNED (TREE_TYPE (@0)) + && tree_int_cst_lt (TYPE_SIZE (type), TYPE_SIZE (TREE_TYPE (@0)))))) + /* x > y && x != XXX_MIN --> x > y x > y && x == XXX_MIN --> false . */ (for eqne (eq ne) diff --git a/gcc/optabs.def b/gcc/optabs.def index bc2611abdc2..4eaffe96c19 100644 --- a/gcc/optabs.def +++ b/gcc/optabs.def @@ -63,6 +63,9 @@ OPTAB_CX(fractuns_optab, "fractuns$Q$b$I$a2") OPTAB_CL(satfract_optab, "satfract$b$Q$a2", SAT_FRACT, "satfract", gen_satfract_conv_libfunc) OPTAB_CL(satfractuns_optab, "satfractuns$I$b$Q$a2", UNSIGNED_SAT_FRACT, "satfractuns", gen_satfractuns_conv_libfunc) +OPTAB_CL(ustrunc_optab, "ustrunc$b$a2", US_TRUNCATE, "ustrunc", gen_satfract_conv_libfunc) +OPTAB_CL(sstrunc_optab, "sstrunc$b$a2", SS_TRUNCATE, "sstrunc", gen_satfract_conv_libfunc) + OPTAB_CD(sfixtrunc_optab, "fix_trunc$F$b$I$a2") OPTAB_CD(ufixtrunc_optab, "fixuns_trunc$F$b$I$a2") diff --git a/gcc/tree-ssa-math-opts.cc b/gcc/tree-ssa-math-opts.cc index 57085488722..64bc70c29b3 100644 --- a/gcc/tree-ssa-math-opts.cc +++ b/gcc/tree-ssa-math-opts.cc @@ -4088,6 +4088,7 @@ arith_overflow_check_p (gimple *stmt, gimple *cast_stmt, gimple *&use_stmt, extern bool gimple_unsigned_integer_sat_add (tree, tree*, tree (*)(tree)); extern bool gimple_unsigned_integer_sat_sub (tree, tree*, tree (*)(tree)); +extern bool gimple_unsigend_integer_sat_trunc (tree, tree*, tree (*)(tree)); static void build_saturation_binary_arith_call (gimple_stmt_iterator *gsi, internal_fn fn, @@ -4216,6 +4217,36 @@ match_unsigned_saturation_sub (gimple_stmt_iterator *gsi, gphi *phi) ops[0], ops[1]); } +/* + * Try to match saturation unsigned sub. + * uint16_t x_4(D); + * uint8_t _6; + * overflow_5 = x_4(D) > 255; + * _1 = (unsigned char) x_4(D); + * _2 = (unsigned char) overflow_5; + * _3 = -_2; + * _6 = _1 | _3; + * => + * _6 = .SAT_TRUNC (x_4(D)); + * */ +static void +match_unsigned_saturation_trunc (gimple_stmt_iterator *gsi, gassign *stmt) +{ + tree ops[1]; + tree lhs = gimple_assign_lhs (stmt); + tree type = TREE_TYPE (lhs); + + if (gimple_unsigend_integer_sat_trunc (lhs, ops, NULL) + && direct_internal_fn_supported_p (IFN_SAT_TRUNC, + tree_pair (type, TREE_TYPE (ops[0])), + OPTIMIZE_FOR_BOTH)) + { + gcall *call = gimple_build_call_internal (IFN_SAT_TRUNC, 1, ops[0]); + gimple_call_set_lhs (call, lhs); + gsi_replace (gsi, call, /* update_eh_info */ true); + } +} + /* Recognize for unsigned x x = y - z; if (x > y) @@ -6188,6 +6219,7 @@ math_opts_dom_walker::after_dom_children (basic_block bb) case BIT_IOR_EXPR: match_unsigned_saturation_add (&gsi, as_a (stmt)); + match_unsigned_saturation_trunc (&gsi, as_a (stmt)); /* fall-through */ case BIT_XOR_EXPR: match_uaddc_usubc (&gsi, stmt, code); diff --git a/gcc/tree.cc b/gcc/tree.cc index 2d2d5b6db6e..4572e6fc42b 100644 --- a/gcc/tree.cc +++ b/gcc/tree.cc @@ -2944,6 +2944,28 @@ integer_all_onesp (const_tree expr) == wi::to_wide (expr)); } +/* Return true if EXPR is an integer constant of all ones with half + truncated in precision. Or return false. For example: + uint16_t a = 255; // true. + uint16_t b = 0; // false. + uint16_t c = 65545; // false. */ +bool +integer_half_truncated_all_ones_p (const_tree expr) +{ + if (TREE_CODE (expr) != INTEGER_CST) + return false; + + unsigned precision = TYPE_PRECISION (TREE_TYPE (expr)); + + gcc_assert (precision <= 64); + + unsigned trunc_prec = precision / 2; + wide_int trunc_max = wi::uhwi ((uint64_t)-1 >> (64 - trunc_prec), precision); + wide_int expr_int = wi::to_wide (expr, precision); + + return trunc_max == expr_int; +} + /* Return true if EXPR is the integer constant minus one, or a location wrapper for such a constant. */ diff --git a/gcc/tree.h b/gcc/tree.h index 28e8e71b036..0237826dd23 100644 --- a/gcc/tree.h +++ b/gcc/tree.h @@ -5205,6 +5205,12 @@ extern bool integer_each_onep (const_tree); extern bool integer_all_onesp (const_tree); +/* integer_half_truncated_all_ones_p (tree x) will return true if x is + the integer constant that the half truncated bits are all 1. + For example, uint16_t type with 255 constant integer will be true. */ + +extern bool integer_half_truncated_all_ones_p (const_tree expr); + /* integer_minus_onep (tree x) is nonzero if X is an integer constant of value -1. */