c-common.c::shorten_compare has code to canonicalize the arguments of a
comparison so that the constant is the second argument. This patch
removes the implementation from c-common.c and instead implements it in
match.pd.
Note the match.pd tries to match the prior behavior of shorten_compare,
hence the strange handling of zero. No justification exists AFAIK for
that strange handling in shorten_compare.
The match.pd pattern is primarily Kai's -- I just took the 4 patterns he
wrote and squashed them into a single pattern to avoid the test duplication.
The xfailed testcase is only case I saw across my comparison tests where
this change regressed. Basically shorten-compare had something
non-canonical when called. It was able to canonicalize, then optimize
the result. I just wanted a record of that test in the testsuite.
Obviously if we hit our goal of implementing everything from
shorten_compare, that test will no longer need to be xfailed :-)
Bootstrapped and regression tested on x86-linux-gnu. OK for the trunk?
* c-common.c (shorten_compare): Remove code to swap arguments
if the first is a constant and the second is not zero.
* match.md: Add patterns to canonicalize comparisons so that the
constant argument is second.
* short-compare-3.c: New test, currently xfailed.
kkk
diff --git a/gcc/c-family/c-common.c b/gcc/c-family/c-common.c
index 36c984c..8ba4f13 100644
--- a/gcc/c-family/c-common.c
+++ b/gcc/c-family/c-common.c
@@ -4364,41 +4364,6 @@ shorten_compare (location_t loc, tree *op0_ptr, tree
*op1_ptr,
real1 = TREE_CODE (TREE_TYPE (primop0)) == REAL_TYPE;
real2 = TREE_CODE (TREE_TYPE (primop1)) == REAL_TYPE;
- /* If first arg is constant, swap the args (changing operation
- so value is preserved), for canonicalization. Don't do this if
- the second arg is 0. */
-
- if (TREE_CONSTANT (primop0)
- && !integer_zerop (primop1) && !real_zerop (primop1)
- && !fixed_zerop (primop1))
- {
- std::swap (primop0, primop1);
- std::swap (op0, op1);
- *op0_ptr = op0;
- *op1_ptr = op1;
- std::swap (unsignedp0, unsignedp1);
- std::swap (real1, real2);
-
- switch (code)
- {
- case LT_EXPR:
- code = GT_EXPR;
- break;
- case GT_EXPR:
- code = LT_EXPR;
- break;
- case LE_EXPR:
- code = GE_EXPR;
- break;
- case GE_EXPR:
- code = LE_EXPR;
- break;
- default:
- break;
- }
- *rescode_ptr = code;
- }
-
/* If comparing an integer against a constant more bits wide,
maybe we can deduce a value of 1 or 0 independent of the data.
Or else truncate the constant now
diff --git a/gcc/match.pd b/gcc/match.pd
index bf4da61..1f6dbfe 100644
--- a/gcc/match.pd
+++ b/gcc/match.pd
@@ -1182,6 +1182,25 @@ along with GCC; see the file COPYING3. If not see
(convert (bit_and (op (convert:utype @0) (convert:utype @1))
(convert:utype @4)))))))
+/* This pattern canonicalizes comparisons so the constant operand
+ is second, unless the constant operand is zero.
+
+ This mirrors the prior behaviour of shorten_comparison. There wasn't
+ any justification for the special handling of zero in
+ shorten_comparison. */
+(for op (lt gt le ge)
+ (simplify
+ (op CONSTANT_CLASS_P@0 @1)
+ (if (!integer_zerop (@1) && !real_zerop (@1) && !fixed_zerop (@1)
+ && (TREE_CODE (TREE_TYPE (@0)) != REAL_TYPE
+ || !DECIMAL_FLOAT_MODE_P (TYPE_MODE (TREE_TYPE (@0))))
+ && (TREE_CODE (TREE_TYPE (@1)) != REAL_TYPE
+ || !DECIMAL_FLOAT_MODE_P (TYPE_MODE (TREE_TYPE (@1)))))
+ (if (op == LT_EXPR) (gt @1 @0))
+ (if (op == GT_EXPR) (lt @1 @0))
+ (if (op == LE_EXPR) (ge @1 @0))
+ (if (op == GE_EXPR) (le @1 @0)))))
+
/* fold-const has a rich set of optimizations for expressions of the
form A op B ? A : B. However, those optimizations can be easily
confused by typecasting, particularly in the true/false arms of the
--- /dev/null 2015-05-20 16:48:49.438489869 -0600
+++ testsuite/gcc.dg/short-compare-3.c 2015-05-29 22:28:50.931836673 -0600
@@ -0,0 +1,15 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -fdump-tree-original" } */
+
+extern unsigned short mode_size[];
+void oof (void);
+void
+fu ()
+{
+ if (64 >= mode_size[42])
+ oof ();
+}
+
+/* { dg-final { scan-tree-dump-times "\(int\)" 0 "original" {xfail *-*-*}} } */
+/* { dg-final { cleanup-tree-dump "original" } } */
+
