diff --git a/gcc/generic-match-head.cc b/gcc/generic-match-head.cc
index ddaf22f2179456f82630c82b7f0a585342d6af58..f40a35c48a6e0aa76eb296c775c9c608562dd49f 100644
--- a/gcc/generic-match-head.cc
+++ b/gcc/generic-match-head.cc
@@ -127,10 +127,11 @@ bitwise_equal_p (tree expr1, tree expr2)
    The types can differ through nop conversions.  */
 
 static inline bool
-bitwise_inverted_equal_p (tree expr1, tree expr2)
+bitwise_inverted_equal_p (tree expr1, tree expr2, bool &wascmp)
 {
   STRIP_NOPS (expr1);
   STRIP_NOPS (expr2);
+  wascmp = false;
   if (expr1 == expr2)
     return false;
   if (!tree_nop_conversion_p (TREE_TYPE (expr1), TREE_TYPE (expr2)))
@@ -150,6 +151,7 @@ bitwise_inverted_equal_p (tree expr1, tree expr2)
     {
       tree op10 = TREE_OPERAND (expr1, 0);
       tree op20 = TREE_OPERAND (expr2, 0);
+      wascmp = true;
       if (!operand_equal_p (op10, op20))
 	return false;
       tree op11 = TREE_OPERAND (expr1, 1);
diff --git a/gcc/gimple-match-head.cc b/gcc/gimple-match-head.cc
index a097a494c3932a8198280bcd1e65e6c2f465f125..ea6387a1099dc78f4cc05c4eaa0ea2d08fce1164 100644
--- a/gcc/gimple-match-head.cc
+++ b/gcc/gimple-match-head.cc
@@ -267,8 +267,8 @@ gimple_bitwise_equal_p (tree expr1, tree expr2, tree (*valueize) (tree))
 /* Return true if EXPR1 and EXPR2 have the bitwise opposite value,
    but not necessarily same type.
    The types can differ through nop conversions.  */
-#define bitwise_inverted_equal_p(expr1, expr2) \
-  gimple_bitwise_inverted_equal_p (expr1, expr2, valueize)
+#define bitwise_inverted_equal_p(expr1, expr2, wascmp) \
+  gimple_bitwise_inverted_equal_p (expr1, expr2, wascmp, valueize)
 
 
 bool gimple_bit_not_with_nop (tree, tree *, tree (*) (tree));
@@ -277,8 +277,9 @@ bool gimple_maybe_cmp (tree, tree *, tree (*) (tree));
 /* Helper function for bitwise_equal_p macro.  */
 
 static inline bool
-gimple_bitwise_inverted_equal_p (tree expr1, tree expr2, tree (*valueize) (tree))
+gimple_bitwise_inverted_equal_p (tree expr1, tree expr2, bool &wascmp, tree (*valueize) (tree))
 {
+  wascmp = false;
   if (expr1 == expr2)
     return false;
   if (!tree_nop_conversion_p (TREE_TYPE (expr1), TREE_TYPE (expr2)))
@@ -331,6 +332,7 @@ gimple_bitwise_inverted_equal_p (tree expr1, tree expr2, tree (*valueize) (tree)
   tree op21 = do_valueize (valueize, gimple_assign_rhs2 (a2));
   if (!operand_equal_p (op11, op21))
     return false;
+  wascmp = true;
   if (invert_tree_comparison (gimple_assign_rhs_code (a1),
 			      HONOR_NANS (op10))
 	== gimple_assign_rhs_code (a2))
diff --git a/gcc/match.pd b/gcc/match.pd
index fc630b63563fd352d5d60a2774210afd785be48a..6791060891dc1d14f974f93b5ad7c9bd11a6a2ab 100644
--- a/gcc/match.pd
+++ b/gcc/match.pd
@@ -1179,9 +1179,10 @@ DEFINE_INT_AND_FLOAT_ROUND_FN (RINT)
 /* Simplify ~X & X as zero.  */
 (simplify
  (bit_and (convert? @0) (convert? @1))
- (if (types_match (TREE_TYPE (@0), TREE_TYPE (@1))
-      && bitwise_inverted_equal_p (@0, @1))
-  { build_zero_cst (type); }))
+ (with { bool wascmp; }
+  (if (types_match (TREE_TYPE (@0), TREE_TYPE (@1))
+       && bitwise_inverted_equal_p (@0, @1, wascmp))
+   { wascmp ? constant_boolean_node (false, type) : build_zero_cst (type); })))
 
 /* PR71636: Transform x & ((1U << b) - 1) -> x & ~(~0U << b);  */
 (simplify
@@ -1419,9 +1420,13 @@ DEFINE_INT_AND_FLOAT_ROUND_FN (RINT)
 (for op (bit_ior bit_xor)
  (simplify
   (op (convert? @0) (convert? @1))
-  (if (types_match (TREE_TYPE (@0), TREE_TYPE (@1))
-       && bitwise_inverted_equal_p (@0, @1))
-   (convert { build_all_ones_cst (TREE_TYPE (@0)); }))))
+  (with { bool wascmp; }
+   (if (types_match (TREE_TYPE (@0), TREE_TYPE (@1))
+        && bitwise_inverted_equal_p (@0, @1, wascmp))
+    (convert
+     { wascmp
+        ? constant_boolean_node (true, type)
+	: build_all_ones_cst (TREE_TYPE (@0)); })))))
 
 /* x ^ x -> 0 */
 (simplify
@@ -1969,8 +1974,10 @@ DEFINE_INT_AND_FLOAT_ROUND_FN (RINT)
  /* (~x & y) | x -> x | y */
  (simplify
   (bitop:c (rbitop:c @2 @1) @0)
-  (if (bitwise_inverted_equal_p (@0, @2))
-   (bitop @0 @1))))
+  (with { bool wascmp; }
+   (if (bitwise_inverted_equal_p (@0, @2, wascmp)
+	&& (!wascmp || element_precision (type) == 1))
+    (bitop @0 @1)))))
 
 /* ((x | y) & z) | x -> (z & y) | x */
 (simplify
@@ -6464,14 +6471,16 @@ DEFINE_INT_AND_FLOAT_ROUND_FN (RINT)
 /* a?~t:t -> (-(a))^t */
 (simplify
  (cond @0 @1 @2)
- (if (INTEGRAL_TYPE_P (type)
-      && bitwise_inverted_equal_p (@1, @2))
-  (with {
-    auto prec = TYPE_PRECISION (type);
-    auto unsign = TYPE_UNSIGNED (type);
-    tree inttype = build_nonstandard_integer_type (prec, unsign);
-   }
-   (convert (bit_xor (negate (convert:inttype @0)) (convert:inttype @2))))))
+ (with { bool wascmp; }
+  (if (INTEGRAL_TYPE_P (type)
+       && bitwise_inverted_equal_p (@1, @2, wascmp)
+       && (!wascmp || element_precision (type) == 1))
+   (with {
+     auto prec = TYPE_PRECISION (type);
+     auto unsign = TYPE_UNSIGNED (type);
+     tree inttype = build_nonstandard_integer_type (prec, unsign);
+    }
+    (convert (bit_xor (negate (convert:inttype @0)) (convert:inttype @2)))))))
 #endif
 
 /* Simplify pointer equality compares using PTA.  */
diff --git a/gcc/testsuite/gcc.c-torture/execute/pr110954-1.c b/gcc/testsuite/gcc.c-torture/execute/pr110954-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..8aad758e10f8ff0be28b6d90bbb9151dea84cf1e
--- /dev/null
+++ b/gcc/testsuite/gcc.c-torture/execute/pr110954-1.c
@@ -0,0 +1,10 @@
+
+#define comparison (f < 0)
+int main() {
+  int f = 0;
+  int d = comparison | !comparison;
+  if (d != 1)
+    __builtin_abort();
+  return 0;
+}
+