[PATCH] [tree-optimization] Fix for PR97223

[Eugene Rozenfeld <Eugene.Rozenfeld@microsoft.com>]

[-- Attachment #1: Type: text/plain, Size: 533 bytes --]

This patch adds a pattern for folding 
                x < (short) ((unsigned short)x + const)
to
	 x <= SHORT_MAX - const
(and similarly for other integral types) if const is not 0.
as described in PR97223.

For example, without this patch the x86_64-pc-linux code generated for this function

bool f(char x)
{
    return x < (char)(x + 12);
}

is

lea    eax,[rdi+0xc]
cmp    al,dil
setg   al
ret  

With the patch the code is 

cmp    dil,0x73
setle  al
ret    

Tested on x86_64-pc-linux.

Eugene


[-- Attachment #2: 0001-Add-a-tree-optimization-described-in-PR97223.patch --]
[-- Type: application/octet-stream, Size: 1923 bytes --]

From bc5fca4cbafae6b6bbf55787af1d2e5d1538649b Mon Sep 17 00:00:00 2001
From: Eugene Rozenfeld <erozen@microsoft.com>
Date: Fri, 23 Oct 2020 16:47:01 -0700
Subject: [PATCH] Add a tree optimization described in PR97223.
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Convert
x < (short) ((unsigned short)x + const)
to
x <= SHORT_MAX – const
(and similarly for other integral types) if const is not 0.

For example, without this patch the x86_64-pc-linux code generated for this function

bool f(char x)
{
    return x < (char)(x + 12);
}

is

lea    eax,[rdi+0xc]
cmp    al,dil
setg   al
ret

With the patch the code is

cmp    dil,0x73
setle  al
ret
---
 gcc/match.pd | 16 ++++++++++++++++
 1 file changed, 16 insertions(+)

diff --git a/gcc/match.pd b/gcc/match.pd
index 17ba04100c7..bc5bed626ec 100644
--- a/gcc/match.pd
+++ b/gcc/match.pd
@@ -4954,6 +4954,22 @@ DEFINE_INT_AND_FLOAT_ROUND_FN (RINT)
 			        wi::max_value (prec, UNSIGNED)
 				- wi::to_wide (@1)); })))))
 
+/* Similar to the previous pattern but with additional casts. */
+(for cmp (lt le ge gt)
+     out (gt gt le le)
+ (simplify
+  (cmp:c (convert@3 (plus@2 (convert@4 @0) INTEGER_CST@1)) @0)
+  (if (!TYPE_UNSIGNED (TREE_TYPE (@0))
+       && types_match (TREE_TYPE (@0), TREE_TYPE (@3))
+       && types_match (TREE_TYPE (@4), unsigned_type_for (TREE_TYPE (@0)))
+       && TYPE_OVERFLOW_WRAPS (TREE_TYPE (@4))
+       && wi::to_wide (@1) != 0
+       && single_use (@2))
+   (with { unsigned int prec = TYPE_PRECISION (TREE_TYPE (@0)); }
+    (out @0 { wide_int_to_tree (TREE_TYPE (@0),
+			        wi::max_value (prec, SIGNED)
+				- wi::to_wide (@1)); })))))
+
 /* To detect overflow in unsigned A - B, A < B is simpler than A - B > A.
    However, the detection logic for SUB_OVERFLOW in tree-ssa-math-opts.c
    expects the long form, so we restrict the transformation for now.  */
-- 
2.17.1