Address comments

Author: davemgreen

llvm/lib/Transforms/InstCombine/InstCombineCompares.cpp

@@ -1223,6 +1223,33 @@ Instruction *InstCombinerImpl::foldSignBitTest(ICmpInst &I) {
                           X, ConstantInt::getNullValue(XTy));
 }
 
+/// Combine away instructions providing they are still equivalent when compared
+/// against 0. i.e do they have any bits set.
+static Value *combineAwayHasAnyBitsSetChain(Value *V,
+                                            InstCombiner::BuilderTy &Builder) {
+  auto *I = dyn_cast<Instruction>(V);
+  if (!I || I->getOpcode() != Instruction::Or || !I->hasOneUse())
+    return nullptr;
+
+  // Remove the shl in or(shl(x, y), z) so long as the shl is nuw or nsw.
+  Value *A, *B;
+  if (match(I, m_c_Or(m_CombineOr(m_NSWShl(m_Value(A), m_Value()),
+                                  m_NUWShl(m_Value(A), m_Value())),
+                      m_Value(B))))
+    return Builder.CreateOr(A, B);
+
+  // Look deeper into the chain of or's.
+  Value *Op0 = I->getOperand(0);
+  if (auto *NOp = combineAwayHasAnyBitsSetChain(Op0, Builder))
+    Op0 = NOp;
+  Value *Op1 = I->getOperand(1);
+  if (auto *NOp = combineAwayHasAnyBitsSetChain(Op1, Builder))
+    Op1 = NOp;
+  if (Op0 != I->getOperand(0) || Op1 != I->getOperand(1))
+    return Builder.CreateOr(Op0, Op1);
+  return nullptr;
+}
+
 // Handle  icmp pred X, 0
 Instruction *InstCombinerImpl::foldICmpWithZero(ICmpInst &Cmp) {
   CmpInst::Predicate Pred = Cmp.getPredicate();
@@ -1298,6 +1325,12 @@ Instruction *InstCombinerImpl::foldICmpWithZero(ICmpInst &Cmp) {
     // eq/ne (mul X, Y)) with (icmp eq/ne X/Y) and if X/Y is known non-zero that
     // will fold to a constant elsewhere.
   }
+
+  // icmp eq/ne or(shl(a), b), 0 -> icmp eq/ne or(a, b), 0
+  if (ICmpInst::isEquality(Pred))
+    if (auto *Res = combineAwayHasAnyBitsSetChain(Cmp.getOperand(0), Builder))
+      return new ICmpInst(Pred, Res, Cmp.getOperand(1));
+
   return nullptr;
 }
 
@@ -5046,29 +5079,6 @@ static Instruction *foldICmpOrXX(ICmpInst &I, const SimplifyQuery &Q,
   return nullptr;
 }
 
-static Value *foldShiftAwayFromOrChain(Instruction &I,
-                                       InstCombiner::BuilderTy &Builder) {
-  if (I.getOpcode() != Instruction::Or)
-    return nullptr;
-  Value *A, *B;
-  if (match(&I, m_c_Or(m_CombineOr(m_NSWShl(m_Value(A), m_Value()),
-                                   m_NUWShl(m_Value(A), m_Value())),
-                       m_Value(B))))
-    return Builder.CreateOr(A, B);
-
-  Value *Op0 = I.getOperand(0);
-  if (isa<Instruction>(Op0))
-    if (auto *X = foldShiftAwayFromOrChain(*cast<Instruction>(Op0), Builder))
-      Op0 = X;
-  Value *Op1 = I.getOperand(1);
-  if (isa<Instruction>(Op1))
-    if (auto *X = foldShiftAwayFromOrChain(*cast<Instruction>(Op1), Builder))
-      Op1 = X;
-  if (Op0 != I.getOperand(0) || Op1 != I.getOperand(1))
-    return Builder.CreateOr(Op0, Op1);
-  return nullptr;
-}
-
 static Instruction *foldICmpXorXX(ICmpInst &I, const SimplifyQuery &Q,
                                   InstCombinerImpl &IC) {
   Value *Op0 = I.getOperand(0), *Op1 = I.getOperand(1), *A;
@@ -7891,11 +7901,6 @@ Instruction *InstCombinerImpl::visitICmpInst(ICmpInst &I) {
     }
   }
 
-  // icmp eq/ne or(shl(a), b), 0 -> icmp eq/ne or(a, b)
-  if (I.isEquality() && match(Op1, m_Zero()) && isa<Instruction>(Op0))
-    if (auto *Res = foldShiftAwayFromOrChain(*cast<Instruction>(Op0), Builder))
-      return new ICmpInst(I.getPredicate(), Res, Op1);
-
   return Changed ? &I : nullptr;
 }
 

llvm/test/Transforms/InstCombine/icmp-of-or-x.ll

@@ -518,3 +518,27 @@ define i1 @remove_shift_chain_abcd(i8 %a, i8 %b, i8 %c, i8 %d, i8 %s) {
   ret i1 %ic
 }
 
+define i1 @remove_shift_chain_abcd_multiuse(i8 %a, i8 %b, i8 %c, i8 %d, i8 %s) {
+; CHECK-LABEL: @remove_shift_chain_abcd_multiuse(
+; CHECK-NEXT:    [[AT:%.*]] = shl nuw i8 [[A:%.*]], [[S:%.*]]
+; CHECK-NEXT:    [[BT:%.*]] = shl nuw i8 [[B:%.*]], 2
+; CHECK-NEXT:    [[CT:%.*]] = shl nuw i8 [[C:%.*]], 1
+; CHECK-NEXT:    [[DT:%.*]] = shl nuw i8 [[D:%.*]], [[S]]
+; CHECK-NEXT:    [[OR1:%.*]] = or i8 [[AT]], [[BT]]
+; CHECK-NEXT:    [[OR2:%.*]] = or i8 [[CT]], [[DT]]
+; CHECK-NEXT:    [[OR:%.*]] = or i8 [[OR1]], [[OR2]]
+; CHECK-NEXT:    [[IC:%.*]] = icmp eq i8 [[OR]], 0
+; CHECK-NEXT:    call void @use.i8(i8 [[OR]])
+; CHECK-NEXT:    ret i1 [[IC]]
+;
+  %at = shl nuw i8 %a, %s
+  %bt = shl nuw i8 %b, 2
+  %ct = shl nuw i8 %c, 1
+  %dt = shl nuw i8 %d, %s
+  %or1 = or i8 %at, %bt
+  %or2 = or i8 %ct, %dt
+  %or = or i8 %or1, %or2
+  %ic = icmp eq i8 %or, 0
+  call void @use.i8(i8 %or)
+  ret i1 %ic
+}