Index: llvm/lib/Transforms/InstCombine/InstCombineCompares.cpp
===================================================================
--- llvm/lib/Transforms/InstCombine/InstCombineCompares.cpp
+++ llvm/lib/Transforms/InstCombine/InstCombineCompares.cpp
@@ -2030,17 +2030,65 @@
     return BinaryOperator::Create(BOpc, CmpP, CmpQ);
   }
 
-  // Are we using xors to bitwise check for a pair of (in)equalities? Convert to
+  // Are we using xors to bitwise check for a pair or pairs of (in)equalities? Convert to
   // a shorter form that has more potential to be folded even further.
-  Value *X1, *X2, *X3, *X4;
-  if (match(OrOp0, m_OneUse(m_Xor(m_Value(X1), m_Value(X2)))) &&
-      match(OrOp1, m_OneUse(m_Xor(m_Value(X3), m_Value(X4))))) {
-    // ((X1 ^ X2) || (X3 ^ X4)) == 0 --> (X1 == X2) && (X3 == X4)
-    // ((X1 ^ X2) || (X3 ^ X4)) != 0 --> (X1 != X2) || (X3 != X4)
-    Value *Cmp12 = Builder.CreateICmp(Pred, X1, X2);
-    Value *Cmp34 = Builder.CreateICmp(Pred, X3, X4);
+  // ((X1 ^ X2) || (X3 ^ X4)) == 0 --> (X1 == X2) && (X3 == X4)
+  // ((X1 ^ X2) || (X3 ^ X4)) != 0 --> (X1 != X2) || (X3 != X4)
+  // ((X1 ^ X2) || (X3 ^ X4) || (X5 ^ X6)) == 0 --> (X1 == X2) && (X3 == X4) && (X5 == X6)
+  // ((X1 ^ X2) || (X3 ^ X4) || (X5 ^ X6)) != 0 --> (X1 != X2) || (X3 != X4) || (X5 != X6)
+  bool Match = false;
+  SmallVector<std::pair<Value *, Value *>, 2> CmpValues;
+  llvm::BinaryOperator *OrOperator = Or;
+
+  while (OrOperator) {
+    Value *OrLhs = OrOperator->getOperand(0),
+          *OrRhs = OrOperator->getOperand(1);
+
+    bool OrLhsIsXor = false;
+    bool OrRhsIsXor = false;
+
+    Value *Lhs, *Rhs;
+    if (match(OrLhs, m_OneUse(m_Xor(m_Value(Lhs), m_Value(Rhs))))) {
+      OrLhsIsXor = true;
+      CmpValues.emplace_back(Lhs, Rhs);
+    }
+
+    if (match(OrRhs, m_OneUse(m_Xor(m_Value(Lhs), m_Value(Rhs))))) {
+      OrRhsIsXor = true;
+      CmpValues.emplace_back(Lhs, Rhs);
+    }
+
+    if (OrLhsIsXor && OrRhsIsXor) {
+      Match = true;
+      break;
+    }
+
+    if (!OrLhsIsXor && !OrRhsIsXor) {
+      break;
+    }
+
+    auto *BO = dyn_cast<BinaryOperator>(OrLhsIsXor ? OrRhs : OrLhs);
+    if (BO && BO->getOpcode() == BinaryOperator::Or) {
+      OrOperator = BO;
+      continue;
+    }
+
+    break;
+  }
+
+  if (Match) {
     auto BOpc = Pred == CmpInst::ICMP_EQ ? Instruction::And : Instruction::Or;
-    return BinaryOperator::Create(BOpc, Cmp12, Cmp34);
+    llvm::Value *LhsCmp = Builder.CreateICmp(Pred, CmpValues.rbegin()->first,
+                                             CmpValues.rbegin()->second);
+
+    for (auto It = CmpValues.rbegin() + 1; It != CmpValues.rend() - 1; ++It) {
+      Value *RhsCmp = Builder.CreateICmp(Pred, It->first, It->second);
+      LhsCmp = Builder.CreateBinOp(BOpc, LhsCmp, RhsCmp);
+    }
+
+    Value *RhsCmp = Builder.CreateICmp(Pred, CmpValues.begin()->first,
+                                       CmpValues.begin()->second);
+    return BinaryOperator::Create(BOpc, LhsCmp, RhsCmp);
   }
 
   return nullptr;
Index: llvm/test/Transforms/InstCombine/icmp-or.ll
===================================================================
--- llvm/test/Transforms/InstCombine/icmp-or.ll
+++ llvm/test/Transforms/InstCombine/icmp-or.ll
@@ -363,3 +363,53 @@
   %r = icmp sgt i8 %or, -1
   ret i1 %r
 }
+
+define i1 @icmp_or_xor_2(i64 %x1, i64 %y1, i64 %x2, i64 %y2) {
+; CHECK-LABEL: @icmp_or_xor_2(
+; CHECK-NEXT:    [[TMP1:%.*]] = icmp eq i64 %y1, %x1
+; CHECK-NEXT:    [[TMP2:%.*]] = icmp eq i64 %y2, %x2
+; CHECK-NEXT:    [[CMP:%.*]] = and i1 [[TMP1]], [[TMP2]]
+; CHECK-NEXT:    ret i1 [[CMP]]
+;
+  %xor = xor i64 %y1, %x1
+  %xor1 = xor i64 %y2, %x2
+  %or = or i64 %xor1, %xor
+  %cmp = icmp eq i64 %or, 0
+  ret i1 %cmp
+}
+
+define i1 @icmp_or_xor_3_1(i64 %x1, i64 %y1, i64 %x2, i64 %y2, i64 %x3, i64 %y3) {
+; CHECK-LABEL: @icmp_or_xor_3_1(
+; CHECK-NEXT:    [[TMP1:%.*]] = icmp eq i64 %y1, %x1
+; CHECK-NEXT:    [[TMP2:%.*]] = icmp eq i64 %y2, %x2
+; CHECK-NEXT:    [[CMP1:%.*]] = and i1 [[TMP1]], [[TMP2]]
+; CHECK-NEXT:    [[TMP3:%.*]] = icmp eq i64 %y3, %x3
+; CHECK-NEXT:    [[CMP2:%.*]] = and i1 [[CMP1]], [[TMP3]]
+; CHECK-NEXT:    ret i1 [[CMP2]]
+;
+  %xor = xor i64 %y1, %x1
+  %xor1 = xor i64 %y2, %x2
+  %or = or i64 %xor1, %xor
+  %xor2 = xor i64 %y3, %x3
+  %or3 = or i64 %or, %xor2
+  %cmp = icmp eq i64 %or3, 0
+  ret i1 %cmp
+}
+
+define i1 @icmp_or_xor_3_2(i64 %x1, i64 %y1, i64 %x2, i64 %y2, i64 %x3, i64 %y3) {
+; CHECK-LABEL: @icmp_or_xor_3_2(
+; CHECK-NEXT:    [[TMP1:%.*]] = icmp eq i64 %y1, %x1
+; CHECK-NEXT:    [[TMP2:%.*]] = icmp eq i64 %y2, %x2
+; CHECK-NEXT:    [[CMP1:%.*]] = and i1 [[TMP1]], [[TMP2]]
+; CHECK-NEXT:    [[TMP3:%.*]] = icmp eq i64 %y3, %x3
+; CHECK-NEXT:    [[CMP2:%.*]] = and i1 [[CMP1]], [[TMP3]]
+; CHECK-NEXT:    ret i1 [[CMP2]]
+;
+  %xor = xor i64 %y1, %x1
+  %xor1 = xor i64 %y2, %x2
+  %or = or i64 %xor1, %xor
+  %xor2 = xor i64 %y3, %x3
+  %or3 = or i64 %xor2, %or
+  %cmp = icmp eq i64 %or3, 0
+  ret i1 %cmp
+}